/i;
+var reHTMLComment = /|/;
+var ALTERNATIVE_TAG_FOR_BR = '';
+
+;// CONCATENATED MODULE: ./src/utils/dom.ts
+
+
+
+
+
+
+
+
+
+
+function isPositionInBox(style, offsetX, offsetY) {
+ var left = parseInt(style.left, 10);
+ var top = parseInt(style.top, 10);
+ var width = parseInt(style.width, 10) + parseInt(style.paddingLeft, 10) + parseInt(style.paddingRight, 10);
+ var height = parseInt(style.height, 10) + parseInt(style.paddingTop, 10) + parseInt(style.paddingBottom, 10);
+ return offsetX >= left && offsetX <= left + width && offsetY >= top && offsetY <= top + height;
+}
+var CLS_PREFIX = 'toastui-editor-';
+function cls() {
+ var names = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ names[_i] = arguments[_i];
+ }
+ var result = [];
+ for (var _a = 0, names_1 = names; _a < names_1.length; _a++) {
+ var name = names_1[_a];
+ var className = void 0;
+ if (Array.isArray(name)) {
+ className = name[0] ? name[1] : null;
+ }
+ else {
+ className = name;
+ }
+ if (className) {
+ result.push("" + CLS_PREFIX + className);
+ }
+ }
+ return result.join(' ');
+}
+function clsWithMdPrefix() {
+ var names = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ names[_i] = arguments[_i];
+ }
+ return names.map(function (className) { return CLS_PREFIX + "md-" + className; }).join(' ');
+}
+function isTextNode(node) {
+ return (node === null || node === void 0 ? void 0 : node.nodeType) === Node.TEXT_NODE;
+}
+function isElemNode(node) {
+ return node && node.nodeType === Node.ELEMENT_NODE;
+}
+function findNodes(element, selector) {
+ var nodeList = toArray_default()(element.querySelectorAll(selector));
+ if (nodeList.length) {
+ return nodeList;
+ }
+ return [];
+}
+function appendNodes(node, nodesToAppend) {
+ nodesToAppend = isArray_default()(nodesToAppend) ? toArray_default()(nodesToAppend) : [nodesToAppend];
+ nodesToAppend.forEach(function (nodeToAppend) {
+ node.appendChild(nodeToAppend);
+ });
+}
+function insertBeforeNode(insertedNode, node) {
+ if (node.parentNode) {
+ node.parentNode.insertBefore(insertedNode, node);
+ }
+}
+function removeNode(node) {
+ if (node.parentNode) {
+ node.parentNode.removeChild(node);
+ }
+}
+function unwrapNode(node) {
+ var result = [];
+ while (node.firstChild) {
+ result.push(node.firstChild);
+ if (node.parentNode) {
+ node.parentNode.insertBefore(node.firstChild, node);
+ }
+ }
+ removeNode(node);
+ return result;
+}
+function toggleClass(element, className, state) {
+ if (isUndefined_default()(state)) {
+ state = !hasClass_default()(element, className);
+ }
+ var toggleFn = state ? (addClass_default()) : (removeClass_default());
+ toggleFn(element, className);
+}
+function createElementWith(contents, target) {
+ var container = document.createElement('div');
+ if (isString_default()(contents)) {
+ container.innerHTML = contents;
+ }
+ else {
+ container.appendChild(contents);
+ }
+ var firstChild = container.firstChild;
+ if (target) {
+ target.appendChild(firstChild);
+ }
+ return firstChild;
+}
+function getOuterWidth(el) {
+ var computed = window.getComputedStyle(el);
+ return (['margin-left', 'margin-right'].reduce(function (acc, type) { return acc + parseInt(computed.getPropertyValue(type), 10); }, 0) + el.offsetWidth);
+}
+function closest(node, found) {
+ var condition;
+ if (isString_default()(found)) {
+ condition = function (target) { return matches_default()(target, found); };
+ }
+ else {
+ condition = function (target) { return target === found; };
+ }
+ while (node && node !== document) {
+ if (isElemNode(node) && condition(node)) {
+ return node;
+ }
+ node = node.parentNode;
+ }
+ return null;
+}
+function getTotalOffset(el, root) {
+ var offsetTop = 0;
+ var offsetLeft = 0;
+ while (el && el !== root) {
+ var top = el.offsetTop, left = el.offsetLeft, offsetParent = el.offsetParent;
+ offsetTop += top;
+ offsetLeft += left;
+ if (offsetParent === root.offsetParent) {
+ break;
+ }
+ el = el.offsetParent;
+ }
+ return { offsetTop: offsetTop, offsetLeft: offsetLeft };
+}
+function finalizeHtml(html, needHtmlText) {
+ var result;
+ if (needHtmlText) {
+ result = html.innerHTML;
+ }
+ else {
+ var frag = document.createDocumentFragment();
+ var childNodes = toArray(html.childNodes);
+ var length = childNodes.length;
+ for (var i = 0; i < length; i += 1) {
+ frag.appendChild(childNodes[i]);
+ }
+ result = frag;
+ }
+ return result;
+}
+function dom_empty(node) {
+ while (node.firstChild) {
+ node.removeChild(node.firstChild);
+ }
+}
+function appendNode(node, appended) {
+ if (isString(appended)) {
+ node.insertAdjacentHTML('beforeend', appended);
+ }
+ else {
+ var nodes = appended.length
+ ? toArray(appended)
+ : [appended];
+ for (var i = 0, len = nodes.length; i < len; i += 1) {
+ node.appendChild(nodes[i]);
+ }
+ }
+}
+function prependNode(node, appended) {
+ if (isString(appended)) {
+ node.insertAdjacentHTML('afterbegin', appended);
+ }
+ else {
+ var nodes = appended.length
+ ? toArray(appended)
+ : [appended];
+ for (var i = nodes.length - 1, len = 0; i >= len; i -= 1) {
+ node.insertBefore(nodes[i], node.firstChild);
+ }
+ }
+}
+function setAttributes(attributes, element) {
+ Object.keys(attributes).forEach(function (attrName) {
+ if (isNil(attributes[attrName])) {
+ element.removeAttribute(attrName);
+ }
+ else {
+ element.setAttribute(attrName, attributes[attrName]);
+ }
+ });
+}
+function replaceBRWithEmptyBlock(html) {
+ // remove br in paragraph to compatible with markdown
+ var replacedHTML = html.replace(/
<\/p>/gi, '');
+ var reHTMLTag = new RegExp(HTML_TAG, 'ig');
+ var htmlTagMatched = replacedHTML.match(reHTMLTag);
+ htmlTagMatched === null || htmlTagMatched === void 0 ? void 0 : htmlTagMatched.forEach(function (htmlTag, index) {
+ if (reBR.test(htmlTag)) {
+ var alternativeTag = ALTERNATIVE_TAG_FOR_BR;
+ if (index) {
+ var prevTag = htmlTagMatched[index - 1];
+ var openTagMatched = prevTag.match(OPEN_TAG);
+ if (openTagMatched && !/br/i.test(openTagMatched[1])) {
+ var tagName = openTagMatched[1];
+ alternativeTag = "<" + tagName + ">";
+ }
+ }
+ replacedHTML = replacedHTML.replace(reBR, alternativeTag);
+ }
+ });
+ return replacedHTML;
+}
+function removeProseMirrorHackNodes(html) {
+ var reProseMirrorImage = /![]()
/g;
+ var reProseMirrorTrailingBreak = / class="ProseMirror-trailingBreak"/g;
+ var resultHTML = html;
+ resultHTML = resultHTML.replace(reProseMirrorImage, '');
+ resultHTML = resultHTML.replace(reProseMirrorTrailingBreak, '');
+ return resultHTML;
+}
+
+;// CONCATENATED MODULE: ./src/plugins/popupWidget.ts
+
+
+
+var pluginKey = new PluginKey('widget');
+var MARGIN = 5;
+var PopupWidget = /** @class */ (function () {
+ function PopupWidget(view, eventEmitter) {
+ var _this = this;
+ this.popup = null;
+ this.removeWidget = function () {
+ if (_this.popup) {
+ _this.rootEl.removeChild(_this.popup);
+ _this.popup = null;
+ }
+ };
+ this.rootEl = view.dom.parentElement;
+ this.eventEmitter = eventEmitter;
+ this.eventEmitter.listen('blur', this.removeWidget);
+ this.eventEmitter.listen('loadUI', function () {
+ _this.rootEl = closest(view.dom.parentElement, "." + cls('defaultUI'));
+ });
+ this.eventEmitter.listen('removePopupWidget', this.removeWidget);
+ }
+ PopupWidget.prototype.update = function (view) {
+ var widget = pluginKey.getState(view.state);
+ this.removeWidget();
+ if (widget) {
+ var node = widget.node, style = widget.style;
+ var _a = view.coordsAtPos(widget.pos), top = _a.top, left = _a.left, bottom = _a.bottom;
+ var height = bottom - top;
+ var rect = this.rootEl.getBoundingClientRect();
+ var relTopPos = top - rect.top;
+ css_default()(node, { opacity: '0' });
+ this.rootEl.appendChild(node);
+ css_default()(node, {
+ position: 'absolute',
+ left: left - rect.left + MARGIN + "px",
+ top: (style === 'bottom' ? relTopPos + height - MARGIN : relTopPos - height) + "px",
+ opacity: '1',
+ });
+ this.popup = node;
+ view.focus();
+ }
+ };
+ PopupWidget.prototype.destroy = function () {
+ this.eventEmitter.removeEventHandler('blur', this.removeWidget);
+ };
+ return PopupWidget;
+}());
+function addWidget(eventEmitter) {
+ return new Plugin({
+ key: pluginKey,
+ state: {
+ init: function () {
+ return null;
+ },
+ apply: function (tr) {
+ return tr.getMeta('widget');
+ },
+ },
+ view: function (editorView) {
+ return new PopupWidget(editorView, eventEmitter);
+ },
+ });
+}
+
+// EXTERNAL MODULE: ../../node_modules/tui-code-snippet/collection/forEachArray.js
+var forEachArray = __webpack_require__(893);
+var forEachArray_default = /*#__PURE__*/__webpack_require__.n(forEachArray);
+;// CONCATENATED MODULE: ./src/helper/image.ts
+
+function addDefaultImageBlobHook(eventEmitter) {
+ eventEmitter.listen('addImageBlobHook', function (blob, callback) {
+ var reader = new FileReader();
+ reader.onload = function (_a) {
+ var target = _a.target;
+ return callback(target.result);
+ };
+ reader.readAsDataURL(blob);
+ });
+}
+function emitImageBlobHook(eventEmitter, blob, type) {
+ var hook = function (imageUrl, altText) {
+ eventEmitter.emit('command', 'addImage', {
+ imageUrl: imageUrl,
+ altText: altText || blob.name || 'image',
+ });
+ };
+ eventEmitter.emit('addImageBlobHook', blob, hook, type);
+}
+function pasteImageOnly(items) {
+ var images = toArray_default()(items).filter(function (_a) {
+ var type = _a.type;
+ return type.indexOf('image') !== -1;
+ });
+ if (images.length === 1) {
+ var item = images[0];
+ if (item) {
+ return item.getAsFile();
+ }
+ }
+ return null;
+}
+
+;// CONCATENATED MODULE: ./src/plugins/dropImage.ts
+
+
+
+function dropImage(_a) {
+ var eventEmitter = _a.eventEmitter;
+ return new Plugin({
+ props: {
+ handleDOMEvents: {
+ drop: function (_, ev) {
+ var _a;
+ var items = (_a = ev.dataTransfer) === null || _a === void 0 ? void 0 : _a.files;
+ if (items) {
+ forEachArray_default()(items, function (item) {
+ if (item.type.indexOf('image') !== -1) {
+ ev.preventDefault();
+ ev.stopPropagation();
+ emitImageBlobHook(eventEmitter, item, ev.type);
+ return false;
+ }
+ return true;
+ });
+ }
+ return true;
+ },
+ },
+ },
+ });
+}
+
+;// CONCATENATED MODULE: ./src/spec/node.ts
+var node_Node = /** @class */ (function () {
+ function Node() {
+ }
+ Object.defineProperty(Node.prototype, "type", {
+ get: function () {
+ return 'node';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Node.prototype.setContext = function (context) {
+ this.context = context;
+ };
+ return Node;
+}());
+/* harmony default export */ var node = (node_Node);
+
+;// CONCATENATED MODULE: ./src/widget/widgetNode.ts
+
+
+
+function widgetNodeView(pmNode) {
+ var dom = document.createElement('span');
+ var node = widgetToDOM(pmNode.attrs.info, pmNode.textContent);
+ dom.className = 'tui-widget';
+ dom.appendChild(node);
+ return { dom: dom };
+}
+function isWidgetNode(pmNode) {
+ return pmNode.type.name === 'widget';
+}
+var Widget = /** @class */ (function (_super) {
+ __extends(Widget, _super);
+ function Widget() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Widget.prototype, "name", {
+ get: function () {
+ return 'widget';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Widget.prototype, "schema", {
+ get: function () {
+ return {
+ attrs: {
+ info: { default: null },
+ },
+ group: 'inline',
+ inline: true,
+ content: 'text*',
+ selectable: false,
+ atom: true,
+ toDOM: function () {
+ return ['span', { class: 'tui-widget' }, 0];
+ },
+ parseDOM: [
+ {
+ tag: 'span.tui-widget',
+ getAttrs: function (dom) {
+ var text = dom.textContent;
+ var _a = text.match(/\$\$(widget\d+)/), info = _a[1];
+ return { info: info };
+ },
+ },
+ ],
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return Widget;
+}(node));
+
+
+;// CONCATENATED MODULE: ./src/base.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var EditorBase = /** @class */ (function () {
+ function EditorBase(eventEmitter) {
+ this.timer = null;
+ this.el = document.createElement('div');
+ this.el.className = 'toastui-editor';
+ this.eventEmitter = eventEmitter;
+ this.placeholder = { text: '' };
+ }
+ EditorBase.prototype.createState = function () {
+ return EditorState.create({
+ schema: this.schema,
+ plugins: this.createPlugins(),
+ });
+ };
+ EditorBase.prototype.initEvent = function () {
+ var _a = this, eventEmitter = _a.eventEmitter, view = _a.view, editorType = _a.editorType;
+ view.dom.addEventListener('focus', function () { return eventEmitter.emit('focus', editorType); });
+ view.dom.addEventListener('blur', function () { return eventEmitter.emit('blur', editorType); });
+ };
+ EditorBase.prototype.emitChangeEvent = function (tr) {
+ this.eventEmitter.emit('caretChange', this.editorType);
+ if (tr.docChanged) {
+ this.eventEmitter.emit('change', this.editorType);
+ }
+ };
+ Object.defineProperty(EditorBase.prototype, "defaultPlugins", {
+ get: function () {
+ var rules = this.createInputRules();
+ var plugins = __spreadArray(__spreadArray([], this.keymaps), [
+ keymap(__assign({ 'Shift-Enter': baseKeymap.Enter }, baseKeymap)),
+ dist_history(),
+ placeholder(this.placeholder),
+ addWidget(this.eventEmitter),
+ dropImage(this.context),
+ ]);
+ return rules ? plugins.concat(rules) : plugins;
+ },
+ enumerable: false,
+ configurable: true
+ });
+ EditorBase.prototype.createInputRules = function () {
+ var widgetRules = getWidgetRules();
+ var rules = widgetRules.map(function (_a) {
+ var rule = _a.rule;
+ return new InputRule(rule, function (state, match, start, end) {
+ var schema = state.schema, tr = state.tr, doc = state.doc;
+ var allMatched = match.input.match(new RegExp(rule, 'g'));
+ var pos = doc.resolve(start);
+ var parent = pos.parent;
+ var count = 0;
+ if (isWidgetNode(parent)) {
+ parent = pos.node(pos.depth - 1);
+ }
+ parent.forEach(function (child) { return isWidgetNode(child) && (count += 1); });
+ // replace the content only if the count of matched rules in whole text is greater than current widget node count
+ if (allMatched.length > count) {
+ var content = last(allMatched);
+ var nodes = createNodesWithWidget(content, schema);
+ // adjust start position based on widget content
+ return tr.replaceWith(end - content.length + 1, end, nodes);
+ }
+ return null;
+ });
+ });
+ return rules.length ? inputRules({ rules: rules }) : null;
+ };
+ EditorBase.prototype.clearTimer = function () {
+ if (this.timer) {
+ clearTimeout(this.timer);
+ this.timer = null;
+ }
+ };
+ EditorBase.prototype.createSchema = function () {
+ return new Schema({
+ nodes: this.specs.nodes,
+ marks: this.specs.marks,
+ });
+ };
+ EditorBase.prototype.createKeymaps = function (useCommandShortcut) {
+ var _a = getDefaultCommands(), undo = _a.undo, redo = _a.redo;
+ var allKeymaps = this.specs.keymaps(useCommandShortcut);
+ var historyKeymap = {
+ 'Mod-z': undo(),
+ 'Shift-Mod-z': redo(),
+ };
+ return useCommandShortcut ? allKeymaps.concat(keymap(historyKeymap)) : allKeymaps;
+ };
+ EditorBase.prototype.createCommands = function () {
+ return this.specs.commands(this.view);
+ };
+ EditorBase.prototype.createPluginProps = function () {
+ var _this = this;
+ return this.extraPlugins.map(function (plugin) { return plugin(_this.eventEmitter); });
+ };
+ EditorBase.prototype.focus = function () {
+ var _this = this;
+ this.clearTimer();
+ // prevent the error for IE11
+ this.timer = setTimeout(function () {
+ _this.view.focus();
+ _this.view.dispatch(_this.view.state.tr.scrollIntoView());
+ });
+ };
+ EditorBase.prototype.blur = function () {
+ this.view.dom.blur();
+ };
+ EditorBase.prototype.destroy = function () {
+ var _this = this;
+ this.clearTimer();
+ this.view.destroy();
+ Object.keys(this).forEach(function (prop) {
+ delete _this[prop];
+ });
+ };
+ EditorBase.prototype.moveCursorToStart = function (focus) {
+ var tr = this.view.state.tr;
+ this.view.dispatch(tr.setSelection(createTextSelection(tr, 1)).scrollIntoView());
+ if (focus) {
+ this.focus();
+ }
+ };
+ EditorBase.prototype.moveCursorToEnd = function (focus) {
+ var tr = this.view.state.tr;
+ this.view.dispatch(tr.setSelection(createTextSelection(tr, tr.doc.content.size - 1)).scrollIntoView());
+ if (focus) {
+ this.focus();
+ }
+ };
+ EditorBase.prototype.setScrollTop = function (top) {
+ this.view.dom.scrollTop = top;
+ };
+ EditorBase.prototype.getScrollTop = function () {
+ return this.view.dom.scrollTop;
+ };
+ EditorBase.prototype.setPlaceholder = function (text) {
+ this.placeholder.text = text;
+ this.view.dispatch(this.view.state.tr.scrollIntoView());
+ };
+ EditorBase.prototype.setHeight = function (height) {
+ css_default()(this.el, { height: height + "px" });
+ };
+ EditorBase.prototype.setMinHeight = function (minHeight) {
+ css_default()(this.el, { minHeight: minHeight + "px" });
+ };
+ EditorBase.prototype.getElement = function () {
+ return this.el;
+ };
+ return EditorBase;
+}());
+/* harmony default export */ var src_base = (EditorBase);
+
+// EXTERNAL MODULE: ../../node_modules/tui-code-snippet/type/isFunction.js
+var isFunction = __webpack_require__(294);
+var isFunction_default = /*#__PURE__*/__webpack_require__.n(isFunction);
+;// CONCATENATED MODULE: ./src/spec/specManager.ts
+
+
+
+
+
+var defaultCommandShortcuts = [
+ 'Enter',
+ 'Shift-Enter',
+ 'Mod-Enter',
+ 'Tab',
+ 'Shift-Tab',
+ 'Delete',
+ 'Backspace',
+ 'Mod-Delete',
+ 'Mod-Backspace',
+ 'ArrowUp',
+ 'ArrowDown',
+ 'ArrowLeft',
+ 'ArrowRight',
+ 'Mod-d',
+ 'Mod-D',
+ 'Alt-ArrowUp',
+ 'Alt-ArrowDown',
+];
+function execCommand(view, command, payload) {
+ view.focus();
+ return command(payload)(view.state, view.dispatch, view);
+}
+var SpecManager = /** @class */ (function () {
+ function SpecManager(specs) {
+ this.specs = specs;
+ }
+ Object.defineProperty(SpecManager.prototype, "nodes", {
+ get: function () {
+ return this.specs
+ .filter(function (spec) { return spec.type === 'node'; })
+ .reduce(function (nodes, _a) {
+ var _b;
+ var name = _a.name, schema = _a.schema;
+ return __assign(__assign({}, nodes), (_b = {}, _b[name] = schema, _b));
+ }, {});
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(SpecManager.prototype, "marks", {
+ get: function () {
+ return this.specs
+ .filter(function (spec) { return spec.type === 'mark'; })
+ .reduce(function (marks, _a) {
+ var _b;
+ var name = _a.name, schema = _a.schema;
+ return __assign(__assign({}, marks), (_b = {}, _b[name] = schema, _b));
+ }, {});
+ },
+ enumerable: false,
+ configurable: true
+ });
+ SpecManager.prototype.commands = function (view, addedCommands) {
+ var specCommands = this.specs
+ .filter(function (_a) {
+ var commands = _a.commands;
+ return commands;
+ })
+ .reduce(function (allCommands, spec) {
+ var commands = {};
+ var specCommand = spec.commands();
+ if (isFunction_default()(specCommand)) {
+ commands[spec.name] = function (payload) { return execCommand(view, specCommand, payload); };
+ }
+ else {
+ Object.keys(specCommand).forEach(function (name) {
+ commands[name] = function (payload) { return execCommand(view, specCommand[name], payload); };
+ });
+ }
+ return __assign(__assign({}, allCommands), commands);
+ }, {});
+ var defaultCommands = getDefaultCommands();
+ Object.keys(defaultCommands).forEach(function (name) {
+ specCommands[name] = function (payload) { return execCommand(view, defaultCommands[name], payload); };
+ });
+ if (addedCommands) {
+ Object.keys(addedCommands).forEach(function (name) {
+ specCommands[name] = function (payload) { return execCommand(view, addedCommands[name], payload); };
+ });
+ }
+ return specCommands;
+ };
+ SpecManager.prototype.keymaps = function (useCommandShortcut) {
+ var specKeymaps = this.specs.filter(function (spec) { return spec.keymaps; }).map(function (spec) { return spec.keymaps(); });
+ return specKeymaps.map(function (keys) {
+ if (!useCommandShortcut) {
+ Object.keys(keys).forEach(function (key) {
+ if (!common_includes(defaultCommandShortcuts, key)) {
+ delete keys[key];
+ }
+ });
+ }
+ return keymap(keys);
+ });
+ };
+ SpecManager.prototype.setContext = function (context) {
+ this.specs.forEach(function (spec) {
+ spec.setContext(context);
+ });
+ };
+ return SpecManager;
+}());
+/* harmony default export */ var specManager = (SpecManager);
+
+;// CONCATENATED MODULE: ./src/markdown/helper/pos.ts
+
+
+function resolveSelectionPos(selection) {
+ var from = selection.from, to = selection.to;
+ if (selection instanceof AllSelection) {
+ return [from + 1, to - 1];
+ }
+ return [from, to];
+}
+function getMdLine(resolvedPos) {
+ return resolvedPos.index(0) + 1;
+}
+function getWidgetNodePos(node, chPos, direction) {
+ if (direction === void 0) { direction = 1; }
+ var additionalPos = 0;
+ node.forEach(function (child, pos) {
+ // add or subtract widget node tag
+ if (isWidgetNode(child) && pos + 2 < chPos) {
+ additionalPos += 2 * direction;
+ }
+ });
+ return additionalPos;
+}
+function getEditorToMdPos(doc, from, to) {
+ if (to === void 0) { to = from; }
+ var collapsed = from === to;
+ var startResolvedPos = doc.resolve(from);
+ var startLine = getMdLine(startResolvedPos);
+ var endLine = startLine;
+ var startOffset = startResolvedPos.start(1);
+ var endOffset = startOffset;
+ if (!collapsed) {
+ // prevent the end offset from pointing to the root document position
+ var endResolvedPos = doc.resolve(to === doc.content.size ? to - 1 : to);
+ endOffset = endResolvedPos.start(1);
+ endLine = getMdLine(endResolvedPos);
+ // To resolve the end offset excluding document tag size
+ if (endResolvedPos.pos === doc.content.size) {
+ to = doc.content.size - 2;
+ }
+ }
+ var startCh = Math.max(from - startOffset + 1, 1);
+ var endCh = Math.max(to - endOffset + 1, 1);
+ return [
+ [startLine, startCh + getWidgetNodePos(doc.child(startLine - 1), startCh, -1)],
+ [endLine, endCh + getWidgetNodePos(doc.child(endLine - 1), endCh, -1)],
+ ];
+}
+function getStartPosListPerLine(doc, endIndex) {
+ var startPosListPerLine = [];
+ for (var i = 0, pos = 0; i < endIndex; i += 1) {
+ var child = doc.child(i);
+ startPosListPerLine[i] = pos;
+ pos += child.nodeSize;
+ }
+ return startPosListPerLine;
+}
+function getMdToEditorPos(doc, startPos, endPos) {
+ var startPosListPerLine = getStartPosListPerLine(doc, endPos[0]);
+ var startIndex = startPos[0] - 1;
+ var endIndex = endPos[0] - 1;
+ var startNode = doc.child(startIndex);
+ var endNode = doc.child(endIndex);
+ // calculate the position corresponding to the line
+ var from = startPosListPerLine[startIndex];
+ var to = startPosListPerLine[endIndex];
+ // calculate the position corresponding to the character offset of the line
+ from += startPos[1] + getWidgetNodePos(startNode, startPos[1] - 1);
+ to += endPos[1] + getWidgetNodePos(endNode, endPos[1] - 1);
+ return [from, Math.min(to, doc.content.size)];
+}
+function getRangeInfo(selection) {
+ var $from = selection.$from, $to = selection.$to;
+ var from = selection.from, to = selection.to;
+ var doc = $from.doc;
+ if (selection instanceof AllSelection) {
+ $from = doc.resolve(from + 1);
+ $to = doc.resolve(to - 1);
+ }
+ if ($from.depth === 0) {
+ $from = doc.resolve(from - 1);
+ $to = $from;
+ }
+ return {
+ startFromOffset: $from.start(1),
+ endFromOffset: $to.start(1),
+ startToOffset: $from.end(1),
+ endToOffset: $to.end(1),
+ startIndex: $from.index(0),
+ endIndex: $to.index(0),
+ from: $from.pos,
+ to: $to.pos,
+ };
+}
+function getNodeContentOffsetRange(doc, targetIndex) {
+ var startOffset = 1;
+ var endOffset = 1;
+ for (var i = 0, offset = 0; i < doc.childCount; i += 1) {
+ var nodeSize = doc.child(i).nodeSize;
+ // calculate content start, end offset(not node offset)
+ startOffset = offset + 1;
+ endOffset = offset + nodeSize - 1;
+ if (i === targetIndex) {
+ break;
+ }
+ offset += nodeSize;
+ }
+ return { startOffset: startOffset, endOffset: endOffset };
+}
+
+;// CONCATENATED MODULE: ./src/markdown/plugins/helper/markInfo.ts
+
+
+
+var HEADING = 'heading';
+var BLOCK_QUOTE = 'blockQuote';
+var LIST_ITEM = 'listItem';
+var TABLE = 'table';
+var TABLE_CELL = 'tableCell';
+var CODE_BLOCK = 'codeBlock';
+var THEMATIC_BREAK = 'thematicBreak';
+var LINK = 'link';
+var CODE = 'code';
+var META = 'meta';
+var DELIM = 'delimiter';
+var TASK_DELIM = 'taskDelimiter';
+var TEXT = 'markedText';
+var HTML = 'html';
+var CUSTOM_BLOCK = 'customBlock';
+var delimSize = {
+ strong: 2,
+ emph: 1,
+ strike: 2,
+};
+function markInfo(start, end, type, attrs) {
+ return { start: start, end: end, spec: { type: type, attrs: attrs } };
+}
+function heading(_a, start, end) {
+ var level = _a.level, headingType = _a.headingType;
+ var marks = [markInfo(start, end, HEADING, { level: level })];
+ if (headingType === 'atx') {
+ marks.push(markInfo(start, addOffsetPos(start, level), DELIM));
+ }
+ else {
+ marks.push(markInfo(setOffsetPos(end, 0), end, HEADING, { seText: true }));
+ }
+ return marks;
+}
+function emphasisAndStrikethrough(_a, start, end) {
+ var type = _a.type;
+ var startDelimPos = addOffsetPos(start, delimSize[type]);
+ var endDelimPos = addOffsetPos(end, -delimSize[type]);
+ return [
+ markInfo(startDelimPos, endDelimPos, type),
+ markInfo(start, startDelimPos, DELIM),
+ markInfo(endDelimPos, end, DELIM),
+ ];
+}
+function markLink(start, end, linkTextStart, lastChildCh) {
+ return [
+ markInfo(start, end, LINK),
+ markInfo(setOffsetPos(start, linkTextStart[1] + 1), setOffsetPos(end, lastChildCh), LINK, {
+ desc: true,
+ }),
+ markInfo(setOffsetPos(end, lastChildCh + 2), addOffsetPos(end, -1), LINK, { url: true }),
+ ];
+}
+function markInfo_image(_a, start, end) {
+ var lastChild = _a.lastChild;
+ var lastChildCh = lastChild ? getMdEndCh(lastChild) + 1 : 3; // 3: length of '![]'
+ var linkTextEnd = addOffsetPos(start, 1);
+ return __spreadArray([markInfo(start, linkTextEnd, META)], markLink(start, end, linkTextEnd, lastChildCh));
+}
+function markInfo_link(_a, start, end) {
+ var lastChild = _a.lastChild, extendedAutolink = _a.extendedAutolink;
+ var lastChildCh = lastChild ? getMdEndCh(lastChild) + 1 : 2; // 2: length of '[]'
+ return extendedAutolink
+ ? [markInfo(start, end, LINK, { desc: true })]
+ : markLink(start, end, start, lastChildCh);
+}
+function markInfo_code(_a, start, end) {
+ var tickCount = _a.tickCount;
+ var openDelimEnd = addOffsetPos(start, tickCount);
+ var closeDelimStart = addOffsetPos(end, -tickCount);
+ return [
+ markInfo(start, end, CODE),
+ markInfo(start, openDelimEnd, CODE, { start: true }),
+ markInfo(openDelimEnd, closeDelimStart, CODE, { marked: true }),
+ markInfo(closeDelimStart, end, CODE, { end: true }),
+ ];
+}
+function lineBackground(parent, start, end, prefix) {
+ var defaultBackground = {
+ start: start,
+ end: end,
+ spec: {
+ attrs: { className: prefix + "-line-background", codeStart: start[0], codeEnd: end[0] },
+ },
+ lineBackground: true,
+ };
+ return parent.type !== 'item' && parent.type !== 'blockQuote'
+ ? [
+ __assign(__assign({}, defaultBackground), { end: start, spec: { attrs: { className: prefix + "-line-background start" } } }),
+ __assign(__assign({}, defaultBackground), { start: [Math.min(start[0] + 1, end[0]), start[1]] }),
+ ]
+ : null;
+}
+function codeBlock(node, start, end, endLine) {
+ var fenceOffset = node.fenceOffset, fenceLength = node.fenceLength, fenceChar = node.fenceChar, info = node.info, infoPadding = node.infoPadding, parent = node.parent;
+ var fenceEnd = fenceOffset + fenceLength;
+ var marks = [markInfo(setOffsetPos(start, 1), end, CODE_BLOCK)];
+ if (fenceChar) {
+ marks.push(markInfo(start, addOffsetPos(start, fenceEnd), DELIM));
+ }
+ if (info) {
+ marks.push(markInfo(addOffsetPos(start, fenceLength), addOffsetPos(start, fenceLength + infoPadding + info.length), META));
+ }
+ var codeBlockEnd = "^(\\s{0,4})(" + fenceChar + "{" + fenceLength + ",})";
+ var reCodeBlockEnd = new RegExp(codeBlockEnd);
+ if (reCodeBlockEnd.test(endLine)) {
+ marks.push(markInfo(setOffsetPos(end, 1), end, DELIM));
+ }
+ var lineBackgroundMarkInfo = lineBackground(parent, start, end, 'code-block');
+ return lineBackgroundMarkInfo ? marks.concat(lineBackgroundMarkInfo) : marks;
+}
+function customBlock(node, start, end) {
+ var _a = node, offset = _a.offset, syntaxLength = _a.syntaxLength, info = _a.info, parent = _a.parent;
+ var syntaxEnd = offset + syntaxLength;
+ var marks = [markInfo(setOffsetPos(start, 1), end, CUSTOM_BLOCK)];
+ marks.push(markInfo(start, addOffsetPos(start, syntaxEnd), DELIM));
+ if (info) {
+ marks.push(markInfo(addOffsetPos(start, syntaxEnd), addOffsetPos(start, syntaxLength + info.length), META));
+ }
+ marks.push(markInfo(setOffsetPos(end, 1), end, DELIM));
+ var lineBackgroundMarkInfo = lineBackground(parent, start, end, 'custom-block');
+ return lineBackgroundMarkInfo ? marks.concat(lineBackgroundMarkInfo) : marks;
+}
+function markListItemChildren(node, markType) {
+ var marks = [];
+ while (node) {
+ var type = node.type;
+ if (type === 'paragraph' || type === 'codeBlock') {
+ marks.push(markInfo([getMdStartLine(node), getMdStartCh(node) - 1], [getMdEndLine(node), getMdEndCh(node) + 1], markType));
+ }
+ node = node.next;
+ }
+ return marks;
+}
+function markParagraphInBlockQuote(node) {
+ var marks = [];
+ while (node) {
+ marks.push(markInfo([getMdStartLine(node), getMdStartCh(node)], [getMdEndLine(node), getMdEndCh(node) + 1], TEXT));
+ node = node.next;
+ }
+ return marks;
+}
+function blockQuote(node, start, end) {
+ var marks = node.parent && node.parent.type !== 'blockQuote' ? [markInfo(start, end, BLOCK_QUOTE)] : [];
+ if (node.firstChild) {
+ var childMarks = [];
+ if (node.firstChild.type === 'paragraph') {
+ childMarks = markParagraphInBlockQuote(node.firstChild.firstChild);
+ }
+ else if (node.firstChild.type === 'list') {
+ childMarks = markListItemChildren(node.firstChild, TEXT);
+ }
+ marks = __spreadArray(__spreadArray([], marks), childMarks);
+ }
+ return marks;
+}
+function getSpecOfListItemStyle(node) {
+ var depth = 0;
+ while (node.parent.parent && node.parent.parent.type === 'item') {
+ node = node.parent.parent;
+ depth += 1;
+ }
+ var attrs = [{ odd: true }, { even: true }][depth % 2];
+ return [LIST_ITEM, __assign(__assign({}, attrs), { listStyle: true })];
+}
+function item(node, start) {
+ var _a = node.listData, padding = _a.padding, task = _a.task;
+ var spec = getSpecOfListItemStyle(node);
+ var marks = [markInfo.apply(void 0, __spreadArray([start, addOffsetPos(start, padding)], spec))];
+ if (task) {
+ marks.push(markInfo(addOffsetPos(start, padding), addOffsetPos(start, padding + 3), TASK_DELIM));
+ marks.push(markInfo(addOffsetPos(start, padding + 1), addOffsetPos(start, padding + 2), META));
+ }
+ return marks.concat(markListItemChildren(node.firstChild, TEXT));
+}
+var markNodeFuncMap = {
+ heading: heading,
+ strong: emphasisAndStrikethrough,
+ emph: emphasisAndStrikethrough,
+ strike: emphasisAndStrikethrough,
+ link: markInfo_link,
+ image: markInfo_image,
+ code: markInfo_code,
+ codeBlock: codeBlock,
+ blockQuote: blockQuote,
+ item: item,
+ customBlock: customBlock,
+};
+var simpleMarkClassNameMap = {
+ thematicBreak: THEMATIC_BREAK,
+ table: TABLE,
+ tableCell: TABLE_CELL,
+ htmlInline: HTML,
+};
+function getMarkInfo(node, start, end, endLine) {
+ var type = node.type;
+ if (isFunction_default()(markNodeFuncMap[type])) {
+ // @ts-ignore
+ return markNodeFuncMap[type](node, start, end, endLine);
+ }
+ if (simpleMarkClassNameMap[type]) {
+ return [markInfo(start, end, simpleMarkClassNameMap[type])];
+ }
+ return null;
+}
+
+;// CONCATENATED MODULE: ./src/markdown/plugins/syntaxHighlight.ts
+
+
+
+
+
+var removingBackgroundIndexMap = {};
+function syntaxHighlight(_a) {
+ var schema = _a.schema, toastMark = _a.toastMark;
+ return new Plugin({
+ appendTransaction: function (transactions, _, newState) {
+ var tr = transactions[0];
+ var newTr = newState.tr;
+ if (tr.docChanged) {
+ var markInfo_1 = [];
+ var editResult = tr.getMeta('editResult');
+ editResult.forEach(function (result) {
+ var nodes = result.nodes, removedNodeRange = result.removedNodeRange;
+ if (nodes.length) {
+ markInfo_1 = markInfo_1.concat(getMarkForRemoving(newTr, nodes));
+ for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+ var parent = nodes_1[_i];
+ var walker = parent.walker();
+ var event = walker.next();
+ while (event) {
+ var node = event.node, entering = event.entering;
+ if (entering) {
+ markInfo_1 = markInfo_1.concat(getMarkForAdding(node, toastMark));
+ }
+ event = walker.next();
+ }
+ }
+ }
+ else if (removedNodeRange) {
+ var maxIndex = newTr.doc.childCount - 1;
+ var _a = removedNodeRange.line, startLine = _a[0], endLine = _a[1];
+ var startIndex = Math.min(startLine, maxIndex);
+ var endIndex = Math.min(endLine, maxIndex);
+ // cache the index to remove code block, custom block background when there are no adding nodes
+ for (var i = startIndex; i <= endIndex; i += 1) {
+ removingBackgroundIndexMap[i] = true;
+ }
+ }
+ });
+ appendMarkTr(newTr, schema, markInfo_1);
+ }
+ return newTr.setMeta('widget', tr.getMeta('widget'));
+ },
+ });
+}
+function isDifferentBlock(doc, index, attrs) {
+ return Object.keys(attrs).some(function (name) { return attrs[name] !== doc.child(index).attrs[name]; });
+}
+function addLineBackground(tr, doc, paragraph, blockPosInfo, attrs) {
+ if (attrs === void 0) { attrs = {}; }
+ var startIndex = blockPosInfo.startIndex, endIndex = blockPosInfo.endIndex, from = blockPosInfo.from, to = blockPosInfo.to;
+ var shouldChangeBlockType = false;
+ for (var i = startIndex; i <= endIndex; i += 1) {
+ // prevent to remove background of the node that need to have background
+ delete removingBackgroundIndexMap[i];
+ shouldChangeBlockType = isDifferentBlock(doc, i, attrs);
+ }
+ if (shouldChangeBlockType) {
+ tr.setBlockType(from, to, paragraph, attrs);
+ }
+}
+function appendMarkTr(tr, schema, marks) {
+ var doc = tr.doc;
+ var paragraph = schema.nodes.paragraph;
+ // get start position per line for lazy calculation
+ var startPosListPerLine = getStartPosListPerLine(doc, doc.childCount);
+ marks.forEach(function (_a) {
+ var start = _a.start, end = _a.end, spec = _a.spec, lineBackground = _a.lineBackground;
+ var startIndex = Math.min(start[0], doc.childCount) - 1;
+ var endIndex = Math.min(end[0], doc.childCount) - 1;
+ var startNode = doc.child(startIndex);
+ var endNode = doc.child(endIndex);
+ // calculate the position corresponding to the line
+ var from = startPosListPerLine[startIndex];
+ var to = startPosListPerLine[endIndex];
+ // calculate the position corresponding to the character offset of the line
+ from += start[1] + getWidgetNodePos(startNode, start[1] - 1);
+ to += end[1] + getWidgetNodePos(endNode, end[1] - 1);
+ if (spec) {
+ if (lineBackground) {
+ var posInfo = { from: from, to: to, startIndex: startIndex, endIndex: endIndex };
+ addLineBackground(tr, doc, paragraph, posInfo, spec.attrs);
+ }
+ else {
+ tr.addMark(from, to, schema.mark(spec.type, spec.attrs));
+ }
+ }
+ else {
+ tr.removeMark(from, to);
+ }
+ });
+ removeBlockBackground(tr, startPosListPerLine, paragraph);
+}
+function removeBlockBackground(tr, startPosListPerLine, paragraph) {
+ Object.keys(removingBackgroundIndexMap).forEach(function (index) {
+ var startIndex = Number(index);
+ // get the end position of the current line with the next node start position.
+ var endIndex = Math.min(Number(index) + 1, tr.doc.childCount - 1);
+ var from = startPosListPerLine[startIndex];
+ // subtract '1' for getting end position of the line
+ var to = startPosListPerLine[endIndex] - 1;
+ if (startIndex === endIndex) {
+ to += 2;
+ }
+ tr.setBlockType(from, to, paragraph);
+ });
+}
+function cacheIndexToRemoveBackground(doc, start, end) {
+ var skipLines = [];
+ removingBackgroundIndexMap = {};
+ for (var i = start[0] - 1; i < end[0]; i += 1) {
+ var node = doc.child(i);
+ var codeEnd = node.attrs.codeEnd;
+ var codeStart = node.attrs.codeStart;
+ if (codeStart && codeEnd && !common_includes(skipLines, codeStart)) {
+ skipLines.push(codeStart);
+ codeEnd = Math.min(codeEnd, doc.childCount);
+ // should subtract '1' to markdown line position
+ // because markdown parser has '1'(not zero) as the start number
+ var startIndex = codeStart - 1;
+ var endIndex = end[0];
+ for (var index = startIndex; index < endIndex; index += 1) {
+ removingBackgroundIndexMap[index] = true;
+ }
+ }
+ }
+}
+function getMarkForRemoving(_a, nodes) {
+ var doc = _a.doc;
+ var start = nodes[0].sourcepos[0];
+ var _b = last(nodes).sourcepos, end = _b[1];
+ var startPos = [start[0], start[1]];
+ var endPos = [end[0], end[1] + 1];
+ var marks = [];
+ cacheIndexToRemoveBackground(doc, start, end);
+ marks.push({ start: startPos, end: endPos });
+ return marks;
+}
+function getMarkForAdding(node, toastMark) {
+ var lineTexts = toastMark.getLineTexts();
+ var startPos = [getMdStartLine(node), getMdStartCh(node)];
+ var endPos = [getMdEndLine(node), getMdEndCh(node) + 1];
+ var markInfo = getMarkInfo(node, startPos, endPos, lineTexts[endPos[0] - 1]);
+ return markInfo !== null && markInfo !== void 0 ? markInfo : [];
+}
+
+;// CONCATENATED MODULE: ./src/markdown/plugins/previewHighlight.ts
+
+
+
+var defaultToolbarStateKeys = [
+ 'taskList',
+ 'orderedList',
+ 'bulletList',
+ 'table',
+ 'strong',
+ 'emph',
+ 'strike',
+ 'heading',
+ 'thematicBreak',
+ 'blockQuote',
+ 'code',
+ 'codeBlock',
+ 'indent',
+ 'outdent',
+];
+function getToolbarStateType(mdNode) {
+ var type = mdNode.type;
+ if (isListNode(mdNode)) {
+ if (mdNode.listData.task) {
+ return 'taskList';
+ }
+ return mdNode.listData.type === 'ordered' ? 'orderedList' : 'bulletList';
+ }
+ if (type.indexOf('table') !== -1) {
+ return 'table';
+ }
+ if (!common_includes(defaultToolbarStateKeys, type)) {
+ return null;
+ }
+ return type;
+}
+function getToolbarState(targetNode) {
+ var toolbarState = {
+ indent: { active: false, disabled: true },
+ outdent: { active: false, disabled: true },
+ };
+ var listEnabled = true;
+ traverseParentNodes(targetNode, function (mdNode) {
+ var type = getToolbarStateType(mdNode);
+ if (!type) {
+ return;
+ }
+ if (type === 'bulletList' || type === 'orderedList') {
+ // to apply the nearlist list state in the nested list
+ if (listEnabled) {
+ toolbarState[type] = { active: true };
+ toolbarState.indent.disabled = false;
+ toolbarState.outdent.disabled = false;
+ listEnabled = false;
+ }
+ }
+ else {
+ toolbarState[type] = { active: true };
+ }
+ });
+ return toolbarState;
+}
+function previewHighlight(_a) {
+ var toastMark = _a.toastMark, eventEmitter = _a.eventEmitter;
+ return new Plugin({
+ view: function () {
+ return {
+ update: function (view, prevState) {
+ var state = view.state;
+ var doc = state.doc, selection = state.selection;
+ if (prevState && prevState.doc.eq(doc) && prevState.selection.eq(selection)) {
+ return;
+ }
+ var from = selection.from;
+ var startChOffset = state.doc.resolve(from).start();
+ var line = state.doc.content.findIndex(from).index + 1;
+ var ch = from - startChOffset;
+ if (from === startChOffset) {
+ ch += 1;
+ }
+ var cursorPos = [line, ch];
+ var mdNode = toastMark.findNodeAtPosition(cursorPos);
+ var toolbarState = getToolbarState(mdNode);
+ eventEmitter.emit('changeToolbarState', {
+ cursorPos: cursorPos,
+ mdNode: mdNode,
+ toolbarState: toolbarState,
+ });
+ eventEmitter.emit('setFocusedNode', mdNode);
+ },
+ };
+ },
+ });
+}
+
+;// CONCATENATED MODULE: ./src/markdown/nodes/doc.ts
+
+
+var Doc = /** @class */ (function (_super) {
+ __extends(Doc, _super);
+ function Doc() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Doc.prototype, "name", {
+ get: function () {
+ return 'doc';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Doc.prototype, "schema", {
+ get: function () {
+ return {
+ content: 'block+',
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return Doc;
+}(node));
+
+
+;// CONCATENATED MODULE: ./src/spec/mark.ts
+var mark_Mark = /** @class */ (function () {
+ function Mark() {
+ }
+ Object.defineProperty(Mark.prototype, "type", {
+ get: function () {
+ return 'mark';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Mark.prototype.setContext = function (context) {
+ this.context = context;
+ };
+ return Mark;
+}());
+/* harmony default export */ var mark = (mark_Mark);
+
+;// CONCATENATED MODULE: ./src/markdown/helper/query.ts
+function getTextByMdLine(doc, mdLine) {
+ return getTextContent(doc, mdLine - 1);
+}
+function getTextContent(doc, index) {
+ return doc.child(index).textContent;
+}
+
+;// CONCATENATED MODULE: ./src/markdown/marks/blockQuote.ts
+
+
+
+
+
+
+var reBlockQuote = /^\s*> ?/;
+var BlockQuote = /** @class */ (function (_super) {
+ __extends(BlockQuote, _super);
+ function BlockQuote() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(BlockQuote.prototype, "name", {
+ get: function () {
+ return 'blockQuote';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(BlockQuote.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('block-quote') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ BlockQuote.prototype.createBlockQuoteText = function (text, isBlockQuote) {
+ return isBlockQuote ? text.replace(reBlockQuote, '').trim() : "> " + text.trim();
+ };
+ BlockQuote.prototype.extendBlockQuote = function () {
+ var _this = this;
+ return function (_a, dispatch) {
+ var selection = _a.selection, doc = _a.doc, tr = _a.tr, schema = _a.schema;
+ var _b = getRangeInfo(selection), endFromOffset = _b.endFromOffset, endToOffset = _b.endToOffset, endIndex = _b.endIndex, to = _b.to;
+ var textContent = getTextContent(doc, endIndex);
+ var isBlockQuote = reBlockQuote.test(textContent);
+ if (isBlockQuote && to > endFromOffset && selection.empty) {
+ var isEmpty = !textContent.replace(reBlockQuote, '').trim();
+ if (isEmpty) {
+ tr.deleteRange(endFromOffset, endToOffset).split(tr.mapping.map(endToOffset));
+ }
+ else {
+ var slicedText = textContent.slice(to - endFromOffset).trim();
+ var node = createTextNode(schema, _this.createBlockQuoteText(slicedText));
+ splitAndExtendBlock(tr, endToOffset, slicedText, node);
+ }
+ dispatch(tr);
+ return true;
+ }
+ return false;
+ };
+ };
+ BlockQuote.prototype.commands = function () {
+ var _this = this;
+ return function () { return function (state, dispatch) {
+ var selection = state.selection, doc = state.doc;
+ var _a = getRangeInfo(selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset, startIndex = _a.startIndex, endIndex = _a.endIndex;
+ var isBlockQuote = reBlockQuote.test(getTextContent(doc, startIndex));
+ var tr = replaceTextNode({
+ state: state,
+ startIndex: startIndex,
+ endIndex: endIndex,
+ from: startFromOffset,
+ createText: function (textContent) { return _this.createBlockQuoteText(textContent, isBlockQuote); },
+ });
+ dispatch(tr.setSelection(createTextSelection(tr, tr.mapping.map(endToOffset))));
+ return true;
+ }; };
+ };
+ BlockQuote.prototype.keymaps = function () {
+ var blockQuoteCommand = this.commands()();
+ return {
+ 'alt-q': blockQuoteCommand,
+ 'alt-Q': blockQuoteCommand,
+ Enter: this.extendBlockQuote(),
+ };
+ };
+ return BlockQuote;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/helper/list.ts
+
+
+
+
+var reList = /(^\s*)([-*+] |[\d]+\. )/;
+var reOrderedList = /(^\s*)([\d])+\.( \[[ xX]])? /;
+var reOrderedListGroup = /^(\s*)((\d+)([.)]\s(?:\[(?:x|\s)\]\s)?))(.*)/;
+var reCanBeTaskList = /(^\s*)([-*+]|[\d]+\.)( \[[ xX]])? /;
+var reBulletListGroup = /^(\s*)([-*+]+(\s(?:\[(?:x|\s)\]\s)?))(.*)/;
+var reTaskList = /(^\s*)([-*+] |[\d]+\. )(\[[ xX]] )/;
+var reBulletTaskList = /(^\s*)([-*+])( \[[ xX]]) /;
+function getListType(text) {
+ return reOrderedList.test(text) ? 'ordered' : 'bullet';
+}
+function getListDepth(mdNode) {
+ var depth = 0;
+ while (mdNode && mdNode.type !== 'document') {
+ if (mdNode.type === 'list') {
+ depth += 1;
+ }
+ mdNode = mdNode.parent;
+ }
+ return depth;
+}
+function findSameDepthList(toastMark, currentLine, depth, backward) {
+ var lineTexts = toastMark.getLineTexts();
+ var lineLen = lineTexts.length;
+ var result = [];
+ var line = currentLine;
+ while (backward ? line < lineLen : line > 1) {
+ line = backward ? line + 1 : line - 1;
+ var mdNode = toastMark.findFirstNodeAtLine(line);
+ var currentListDepth = getListDepth(mdNode);
+ if (currentListDepth === depth) {
+ result.push({ line: line, depth: depth, mdNode: mdNode });
+ }
+ else if (currentListDepth < depth) {
+ break;
+ }
+ }
+ return result;
+}
+function getSameDepthItems(_a) {
+ var toastMark = _a.toastMark, mdNode = _a.mdNode, line = _a.line;
+ var depth = getListDepth(mdNode);
+ var forwardList = findSameDepthList(toastMark, line, depth, false).reverse();
+ var backwardList = findSameDepthList(toastMark, line, depth, true);
+ return forwardList.concat([{ line: line, depth: depth, mdNode: mdNode }]).concat(backwardList);
+}
+function textToBullet(text) {
+ if (!reList.test(text)) {
+ return "* " + text;
+ }
+ var type = getListType(text);
+ if (type === 'bullet' && reCanBeTaskList.test(text)) {
+ text = text.replace(reBulletTaskList, '$1$2 ');
+ }
+ else if (type === 'ordered') {
+ text = text.replace(reOrderedList, '$1* ');
+ }
+ return text;
+}
+function textToOrdered(text, ordinalNum) {
+ if (!reList.test(text)) {
+ return ordinalNum + ". " + text;
+ }
+ var type = getListType(text);
+ if (type === 'bullet' || (type === 'ordered' && reCanBeTaskList.test(text))) {
+ text = text.replace(reCanBeTaskList, "$1" + ordinalNum + ". ");
+ }
+ else if (type === 'ordered') {
+ // eslint-disable-next-line prefer-destructuring
+ var start = reOrderedListGroup.exec(text)[3];
+ if (Number(start) !== ordinalNum) {
+ text = text.replace(reOrderedList, "$1" + ordinalNum + ". ");
+ }
+ }
+ return text;
+}
+function getChangedInfo(doc, sameDepthItems, type, start) {
+ if (start === void 0) { start = 0; }
+ var firstIndex = Number.MAX_VALUE;
+ var lastIndex = 0;
+ var changedResults = sameDepthItems.map(function (_a, index) {
+ var line = _a.line;
+ firstIndex = Math.min(line - 1, firstIndex);
+ lastIndex = Math.max(line - 1, lastIndex);
+ var text = getTextByMdLine(doc, line);
+ text = type === 'bullet' ? textToBullet(text) : textToOrdered(text, index + 1 + start);
+ return { text: text, line: line };
+ });
+ return { changedResults: changedResults, firstIndex: firstIndex, lastIndex: lastIndex };
+}
+function getBulletOrOrdered(type, context) {
+ var sameDepthListInfo = getSameDepthItems(context);
+ return getChangedInfo(context.doc, sameDepthListInfo, type);
+}
+var otherListToList = {
+ bullet: function (context) {
+ return getBulletOrOrdered('bullet', context);
+ },
+ ordered: function (context) {
+ return getBulletOrOrdered('ordered', context);
+ },
+ task: function (_a) {
+ var mdNode = _a.mdNode, doc = _a.doc, line = _a.line;
+ var text = getTextByMdLine(doc, line);
+ if (mdNode.listData.task) {
+ text = text.replace(reTaskList, '$1$2');
+ }
+ else if (isListNode(mdNode)) {
+ text = text.replace(reList, '$1$2[ ] ');
+ }
+ return { changedResults: [{ text: text, line: line }] };
+ },
+};
+var otherNodeToList = {
+ bullet: function (_a) {
+ var doc = _a.doc, line = _a.line;
+ var lineText = getTextByMdLine(doc, line);
+ var changedResults = [{ text: "* " + lineText, line: line }];
+ return { changedResults: changedResults };
+ },
+ ordered: function (_a) {
+ var toastMark = _a.toastMark, doc = _a.doc, line = _a.line, startLine = _a.startLine;
+ var lineText = getTextByMdLine(doc, line);
+ var firstOrderedListNum = 1;
+ var firstOrderedListLine = startLine;
+ var skipped = 0;
+ for (var i = startLine - 1; i > 0; i -= 1) {
+ var mdNode = toastMark.findFirstNodeAtLine(i);
+ var text = getTextByMdLine(doc, i);
+ var canBeListNode = text && !!findClosestNode(mdNode, function (targetNode) { return isListNode(targetNode); });
+ var searchResult = reOrderedListGroup.exec(getTextByMdLine(doc, i));
+ if (!searchResult && !canBeListNode) {
+ break;
+ }
+ if (!searchResult && canBeListNode) {
+ skipped += 1;
+ continue;
+ }
+ var _b = searchResult, indent = _b[1], start = _b[3];
+ // basis on one depth list
+ if (!indent) {
+ firstOrderedListNum = Number(start);
+ firstOrderedListLine = i;
+ break;
+ }
+ }
+ var ordinalNum = firstOrderedListNum + line - firstOrderedListLine - skipped;
+ var changedResults = [{ text: ordinalNum + ". " + lineText, line: line }];
+ return { changedResults: changedResults };
+ },
+ task: function (_a) {
+ var doc = _a.doc, line = _a.line;
+ var lineText = getTextByMdLine(doc, line);
+ var changedResults = [{ text: "* [ ] " + lineText, line: line }];
+ return { changedResults: changedResults };
+ },
+};
+var extendList = {
+ bullet: function (_a) {
+ var line = _a.line, doc = _a.doc;
+ var lineText = getTextByMdLine(doc, line);
+ var _b = reBulletListGroup.exec(lineText), indent = _b[1], delimiter = _b[2];
+ return { listSyntax: "" + indent + delimiter };
+ },
+ ordered: function (_a) {
+ var toastMark = _a.toastMark, line = _a.line, mdNode = _a.mdNode, doc = _a.doc;
+ var depth = getListDepth(mdNode);
+ var lineText = getTextByMdLine(doc, line);
+ var _b = reOrderedListGroup.exec(lineText), indent = _b[1], start = _b[3], delimiter = _b[4];
+ var ordinalNum = Number(start) + 1;
+ var listSyntax = "" + indent + ordinalNum + delimiter;
+ var backwardList = findSameDepthList(toastMark, line, depth, true);
+ var filteredList = backwardList.filter(function (info) {
+ var searchResult = reOrderedListGroup.exec(getTextByMdLine(doc, info.line));
+ return (searchResult &&
+ searchResult[1].length === indent.length &&
+ !!findClosestNode(info.mdNode, function (targetNode) { return isOrderedListNode(targetNode); }));
+ });
+ return __assign({ listSyntax: listSyntax }, getChangedInfo(doc, filteredList, 'ordered', ordinalNum));
+ },
+};
+function getReorderedListInfo(doc, schema, line, ordinalNum, prevIndentLength) {
+ var nodes = [];
+ var lineText = getTextByMdLine(doc, line);
+ var searchResult = reOrderedListGroup.exec(lineText);
+ while (searchResult) {
+ var indent = searchResult[1], delimiter = searchResult[4], text = searchResult[5];
+ var indentLength = indent.length;
+ if (indentLength === prevIndentLength) {
+ nodes.push(createTextNode(schema, "" + indent + ordinalNum + delimiter + text));
+ ordinalNum += 1;
+ line += 1;
+ }
+ else if (indentLength > prevIndentLength) {
+ var nestedListInfo = getReorderedListInfo(doc, schema, line, 1, indentLength);
+ line = nestedListInfo.line;
+ nodes = nodes.concat(nestedListInfo.nodes);
+ }
+ if (indentLength < prevIndentLength || line > doc.childCount) {
+ break;
+ }
+ lineText = getTextByMdLine(doc, line);
+ searchResult = reOrderedListGroup.exec(lineText);
+ }
+ return { nodes: nodes, line: line };
+}
+
+;// CONCATENATED MODULE: ./src/markdown/nodes/paragraph.ts
+
+
+
+
+
+
+
+
+
+
+var reStartSpace = /(^\s{1,4})(.*)/;
+function isBlockUnit(from, to, text) {
+ return from < to || reList.test(text) || reBlockQuote.test(text);
+}
+function isInTableCellNode(doc, schema, selection) {
+ var $pos = selection.$from;
+ if ($pos.depth === 0) {
+ $pos = doc.resolve($pos.pos - 1);
+ }
+ var node = $pos.node(1);
+ var startOffset = $pos.start(1);
+ var contentSize = node.content.size;
+ return (node.rangeHasMark(0, contentSize, schema.marks.table) &&
+ $pos.pos - startOffset !== contentSize &&
+ $pos.pos !== startOffset);
+}
+function createSelection(tr, posInfo) {
+ var from = posInfo.from, to = posInfo.to;
+ if (posInfo.type === 'indent') {
+ var softTabLen = 4;
+ from += softTabLen;
+ to += (posInfo.lineLen + 1) * softTabLen;
+ }
+ else {
+ var spaceLenList = posInfo.spaceLenList;
+ from -= spaceLenList[0];
+ for (var i = 0; i < spaceLenList.length; i += 1) {
+ to -= spaceLenList[i];
+ }
+ }
+ return createTextSelection(tr, from, to);
+}
+var Paragraph = /** @class */ (function (_super) {
+ __extends(Paragraph, _super);
+ function Paragraph() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Paragraph.prototype, "name", {
+ get: function () {
+ return 'paragraph';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Paragraph.prototype, "schema", {
+ get: function () {
+ return {
+ content: 'inline*',
+ attrs: {
+ className: { default: null },
+ codeStart: { default: null },
+ codeEnd: { default: null },
+ },
+ selectable: false,
+ group: 'block',
+ parseDOM: [{ tag: 'div' }],
+ toDOM: function (_a) {
+ var attrs = _a.attrs;
+ return attrs.className
+ ? ['div', { class: clsWithMdPrefix(attrs.className) }, 0]
+ : ['div', 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Paragraph.prototype.reorderList = function (startLine, endLine) {
+ var _a = this.context, view = _a.view, toastMark = _a.toastMark, schema = _a.schema;
+ var _b = view.state, tr = _b.tr, selection = _b.selection, doc = _b.doc;
+ var mdNode = toastMark.findFirstNodeAtLine(startLine);
+ var topListNode = mdNode;
+ while (mdNode && !isBulletListNode(mdNode) && mdNode.parent.type !== 'document') {
+ mdNode = mdNode.parent;
+ if (isOrderedListNode(mdNode)) {
+ topListNode = mdNode;
+ break;
+ }
+ }
+ if (topListNode) {
+ startLine = topListNode.sourcepos[0][0];
+ }
+ var _c = reOrderedListGroup.exec(getTextByMdLine(doc, startLine)), indent = _c[1], start = _c[3];
+ var indentLen = indent.length;
+ var _d = getReorderedListInfo(doc, schema, startLine, Number(start), indentLen), line = _d.line, nodes = _d.nodes;
+ endLine = Math.max(endLine, line - 1);
+ var startOffset = getNodeContentOffsetRange(doc, startLine - 1).startOffset;
+ for (var i = startLine - 1; i <= endLine - 1; i += 1) {
+ var _e = doc.child(i), nodeSize = _e.nodeSize, content = _e.content;
+ var mappedFrom = tr.mapping.map(startOffset);
+ var mappedTo = mappedFrom + content.size;
+ tr.replaceWith(mappedFrom, mappedTo, nodes[i - startLine + 1]);
+ startOffset += nodeSize;
+ }
+ var newSelection = createTextSelection(tr, selection.from, selection.to);
+ view.dispatch(tr.setSelection(newSelection));
+ };
+ Paragraph.prototype.indent = function (tabKey) {
+ var _this = this;
+ if (tabKey === void 0) { tabKey = false; }
+ return function () { return function (state, dispatch) {
+ var schema = state.schema, selection = state.selection, doc = state.doc;
+ var _a = getRangeInfo(selection), from = _a.from, to = _a.to, startFromOffset = _a.startFromOffset, startIndex = _a.startIndex, endIndex = _a.endIndex;
+ if (tabKey && isInTableCellNode(doc, schema, selection)) {
+ return false;
+ }
+ var startLineText = getTextContent(doc, startIndex);
+ if ((tabKey && isBlockUnit(from, to, startLineText)) ||
+ (!tabKey && reList.test(startLineText))) {
+ var tr = replaceTextNode({
+ state: state,
+ from: startFromOffset,
+ startIndex: startIndex,
+ endIndex: endIndex,
+ createText: function (textContent) { return " " + textContent; },
+ });
+ var posInfo = {
+ type: 'indent',
+ from: from,
+ to: to,
+ lineLen: endIndex - startIndex,
+ };
+ dispatch(tr.setSelection(createSelection(tr, posInfo)));
+ if (reOrderedListGroup.test(startLineText)) {
+ _this.reorderList(startIndex + 1, endIndex + 1);
+ }
+ }
+ else if (tabKey) {
+ dispatch(state.tr.insert(to, createTextNode(schema, ' ')));
+ }
+ return true;
+ }; };
+ };
+ Paragraph.prototype.outdent = function (tabKey) {
+ var _this = this;
+ if (tabKey === void 0) { tabKey = false; }
+ return function () { return function (state, dispatch) {
+ var selection = state.selection, doc = state.doc, schema = state.schema;
+ var _a = getRangeInfo(selection), from = _a.from, to = _a.to, startFromOffset = _a.startFromOffset, startIndex = _a.startIndex, endIndex = _a.endIndex;
+ if (tabKey && isInTableCellNode(doc, schema, selection)) {
+ return false;
+ }
+ var startLineText = getTextContent(doc, startIndex);
+ if ((tabKey && isBlockUnit(from, to, startLineText)) ||
+ (!tabKey && reList.test(startLineText))) {
+ var spaceLenList_1 = [];
+ var tr = replaceTextNode({
+ state: state,
+ from: startFromOffset,
+ startIndex: startIndex,
+ endIndex: endIndex,
+ createText: function (textContent) {
+ var searchResult = reStartSpace.exec(textContent);
+ spaceLenList_1.push(searchResult ? searchResult[1].length : 0);
+ return textContent.replace(reStartSpace, '$2');
+ },
+ });
+ var posInfo = { type: 'outdent', from: from, to: to, spaceLenList: spaceLenList_1 };
+ dispatch(tr.setSelection(createSelection(tr, posInfo)));
+ if (reOrderedListGroup.test(startLineText)) {
+ _this.reorderList(startIndex + 1, endIndex + 1);
+ }
+ }
+ else if (tabKey) {
+ var startText = startLineText.slice(0, to - startFromOffset);
+ var startTextWithoutSpace = startText.replace(/\s{1,4}$/, '');
+ var deletStart = to - (startText.length - startTextWithoutSpace.length);
+ dispatch(state.tr.delete(deletStart, to));
+ }
+ return true;
+ }; };
+ };
+ Paragraph.prototype.deleteLines = function () {
+ var _this = this;
+ return function (state, dispatch) {
+ var view = _this.context.view;
+ var _a = getRangeInfo(state.selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset;
+ var deleteRange = function () {
+ dispatch(state.tr.deleteRange(startFromOffset, endToOffset));
+ return true;
+ };
+ return chainCommands(deleteRange, joinForward)(state, dispatch, view);
+ };
+ };
+ Paragraph.prototype.moveDown = function () {
+ return function (state, dispatch) {
+ var doc = state.doc, tr = state.tr, selection = state.selection, schema = state.schema;
+ var _a = getRangeInfo(selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset, endIndex = _a.endIndex;
+ if (endIndex < doc.content.childCount - 1) {
+ var _b = doc.child(endIndex + 1), nodeSize = _b.nodeSize, textContent = _b.textContent;
+ tr.delete(endToOffset, endToOffset + nodeSize)
+ .split(startFromOffset)
+ // subtract 2(start, end tag length) to insert prev line
+ .insert(tr.mapping.map(startFromOffset) - 2, createTextNode(schema, textContent));
+ dispatch(tr);
+ return true;
+ }
+ return false;
+ };
+ };
+ Paragraph.prototype.moveUp = function () {
+ return function (state, dispatch) {
+ var tr = state.tr, doc = state.doc, selection = state.selection, schema = state.schema;
+ var _a = getRangeInfo(selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset, startIndex = _a.startIndex;
+ if (startIndex > 0) {
+ var _b = doc.child(startIndex - 1), nodeSize = _b.nodeSize, textContent = _b.textContent;
+ tr.delete(startFromOffset - nodeSize, startFromOffset)
+ .split(tr.mapping.map(endToOffset))
+ .insert(tr.mapping.map(endToOffset), createTextNode(schema, textContent));
+ dispatch(tr);
+ return true;
+ }
+ return false;
+ };
+ };
+ Paragraph.prototype.commands = function () {
+ return {
+ indent: this.indent(),
+ outdent: this.outdent(),
+ };
+ };
+ Paragraph.prototype.keymaps = function () {
+ return {
+ Tab: this.indent(true)(),
+ 'Shift-Tab': this.outdent(true)(),
+ 'Mod-d': this.deleteLines(),
+ 'Mod-D': this.deleteLines(),
+ 'Alt-ArrowUp': this.moveUp(),
+ 'Alt-ArrowDown': this.moveDown(),
+ };
+ };
+ return Paragraph;
+}(node));
+
+
+;// CONCATENATED MODULE: ./src/markdown/nodes/text.ts
+
+
+var Text = /** @class */ (function (_super) {
+ __extends(Text, _super);
+ function Text() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Text.prototype, "name", {
+ get: function () {
+ return 'text';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Text.prototype, "schema", {
+ get: function () {
+ return {
+ group: 'inline',
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return Text;
+}(node));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/heading.ts
+
+
+
+
+
+var reHeading = /^#{1,6}\s/;
+var Heading = /** @class */ (function (_super) {
+ __extends(Heading, _super);
+ function Heading() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Heading.prototype, "name", {
+ get: function () {
+ return 'heading';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Heading.prototype, "schema", {
+ get: function () {
+ return {
+ attrs: {
+ level: { default: 1 },
+ seText: { default: false },
+ },
+ toDOM: function (_a) {
+ var attrs = _a.attrs;
+ var level = attrs.level, seText = attrs.seText;
+ var classNames = "heading|heading" + level;
+ if (seText) {
+ classNames += '|delimiter|setext';
+ }
+ return ['span', { class: clsWithMdPrefix.apply(void 0, classNames.split('|')) }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Heading.prototype.createHeadingText = function (level, text, curHeadingSyntax) {
+ var textContent = text.replace(curHeadingSyntax, '').trim();
+ var headingText = '';
+ while (level > 0) {
+ headingText += '#';
+ level -= 1;
+ }
+ return headingText + " " + textContent;
+ };
+ Heading.prototype.commands = function () {
+ var _this = this;
+ return function (payload) { return function (state, dispatch) {
+ var level = payload.level;
+ var _a = getRangeInfo(state.selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset, startIndex = _a.startIndex, endIndex = _a.endIndex;
+ var tr = replaceTextNode({
+ state: state,
+ from: startFromOffset,
+ startIndex: startIndex,
+ endIndex: endIndex,
+ createText: function (textContent) {
+ var matchedHeading = textContent.match(reHeading);
+ var curHeadingSyntax = matchedHeading ? matchedHeading[0] : '';
+ return _this.createHeadingText(level, textContent, curHeadingSyntax);
+ },
+ });
+ dispatch(tr.setSelection(createTextSelection(tr, tr.mapping.map(endToOffset))));
+ return true;
+ }; };
+ };
+ return Heading;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/codeBlock.ts
+
+
+
+
+
+
+
+var fencedCodeBlockSyntax = '```';
+var CodeBlock = /** @class */ (function (_super) {
+ __extends(CodeBlock, _super);
+ function CodeBlock() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(CodeBlock.prototype, "name", {
+ get: function () {
+ return 'codeBlock';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(CodeBlock.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('code-block') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ CodeBlock.prototype.commands = function () {
+ return function () { return function (state, dispatch) {
+ var selection = state.selection, schema = state.schema, tr = state.tr;
+ var _a = getRangeInfo(selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset;
+ var fencedNode = createTextNode(schema, fencedCodeBlockSyntax);
+ // add fenced start block
+ tr.insert(startFromOffset, fencedNode).split(startFromOffset + fencedCodeBlockSyntax.length);
+ // add fenced end block
+ tr.split(tr.mapping.map(endToOffset)).insert(tr.mapping.map(endToOffset), fencedNode);
+ dispatch(tr.setSelection(
+ // subtract fenced syntax length and open, close tag(2)
+ createTextSelection(tr, tr.mapping.map(endToOffset) - (fencedCodeBlockSyntax.length + 2))));
+ return true;
+ }; };
+ };
+ CodeBlock.prototype.keepIndentation = function () {
+ var _this = this;
+ return function (_a, dispatch) {
+ var selection = _a.selection, tr = _a.tr, doc = _a.doc, schema = _a.schema;
+ var toastMark = _this.context.toastMark;
+ var _b = getRangeInfo(selection), startFromOffset = _b.startFromOffset, endToOffset = _b.endToOffset, endIndex = _b.endIndex, from = _b.from, to = _b.to;
+ var textContent = getTextContent(doc, endIndex);
+ if (from === to && textContent.trim()) {
+ var matched = textContent.match(/^\s+/);
+ var mdNode = toastMark.findFirstNodeAtLine(endIndex + 1);
+ if (isCodeBlockNode(mdNode) && matched) {
+ var spaces = matched[0];
+ var slicedText = textContent.slice(to - startFromOffset);
+ var node = createTextNode(schema, spaces + slicedText);
+ splitAndExtendBlock(tr, endToOffset, slicedText, node);
+ dispatch(tr);
+ return true;
+ }
+ }
+ return false;
+ };
+ };
+ CodeBlock.prototype.keymaps = function () {
+ var codeBlockCommand = this.commands()();
+ return {
+ 'Shift-Mod-p': codeBlockCommand,
+ 'Shift-Mod-P': codeBlockCommand,
+ Enter: this.keepIndentation(),
+ };
+ };
+ return CodeBlock;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/table.ts
+
+
+
+
+
+
+
+var reEmptyTable = /\||\s/g;
+function createTableHeader(columnCount) {
+ return [createTableRow(columnCount), createTableRow(columnCount, true)];
+}
+function createTableBody(columnCount, rowCount) {
+ var bodyRows = [];
+ for (var i = 0; i < rowCount; i += 1) {
+ bodyRows.push(createTableRow(columnCount));
+ }
+ return bodyRows;
+}
+function createTableRow(columnCount, delim) {
+ var row = '|';
+ for (var i = 0; i < columnCount; i += 1) {
+ row += delim ? ' --- |' : ' |';
+ }
+ return row;
+}
+function createTargetTypes(moveNext) {
+ return moveNext
+ ? { type: 'next', parentType: 'tableHead', childType: 'firstChild' }
+ : { type: 'prev', parentType: 'tableBody', childType: 'lastChild' };
+}
+var Table = /** @class */ (function (_super) {
+ __extends(Table, _super);
+ function Table() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Table.prototype, "name", {
+ get: function () {
+ return 'table';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Table.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('table') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Table.prototype.extendTable = function () {
+ var _this = this;
+ return function (_a, dispatch) {
+ var selection = _a.selection, doc = _a.doc, tr = _a.tr, schema = _a.schema;
+ if (!selection.empty) {
+ return false;
+ }
+ var _b = getRangeInfo(selection), endFromOffset = _b.endFromOffset, endToOffset = _b.endToOffset, endIndex = _b.endIndex, to = _b.to;
+ var textContent = getTextContent(doc, endIndex);
+ // should add `1` to line for the markdown parser
+ // because markdown parser has `1`(not zero) as the start number
+ var mdPos = [endIndex + 1, to - endFromOffset + 1];
+ var mdNode = _this.context.toastMark.findNodeAtPosition(mdPos);
+ var cellNode = findClosestNode(mdNode, function (node) {
+ return isTableCellNode(node) &&
+ (node.parent.type === 'tableDelimRow' || node.parent.parent.type === 'tableBody');
+ });
+ if (cellNode) {
+ var isEmpty = !textContent.replace(reEmptyTable, '').trim();
+ var parent = cellNode.parent;
+ var columnCount = parent.parent.parent.columns.length;
+ var row = createTableRow(columnCount);
+ if (isEmpty) {
+ tr.deleteRange(endFromOffset, endToOffset).split(tr.mapping.map(endToOffset));
+ }
+ else {
+ tr
+ .split(endToOffset)
+ .insert(tr.mapping.map(endToOffset), createTextNode(schema, row))
+ // should subtract `2` to selection end position considering ` |` text
+ .setSelection(createTextSelection(tr, tr.mapping.map(endToOffset) - 2));
+ }
+ dispatch(tr);
+ return true;
+ }
+ return false;
+ };
+ };
+ Table.prototype.moveTableCell = function (moveNext) {
+ var _this = this;
+ return function (_a, dispatch) {
+ var selection = _a.selection, tr = _a.tr;
+ var _b = getRangeInfo(selection), endFromOffset = _b.endFromOffset, endIndex = _b.endIndex, to = _b.to;
+ var mdPos = [endIndex + 1, to - endFromOffset];
+ var mdNode = _this.context.toastMark.findNodeAtPosition(mdPos);
+ var cellNode = findClosestNode(mdNode, function (node) { return isTableCellNode(node); });
+ if (cellNode) {
+ var parent = cellNode.parent;
+ var _c = createTargetTypes(moveNext), type = _c.type, parentType = _c.parentType, childType = _c.childType;
+ var chOffset = getMdEndCh(cellNode);
+ if (cellNode[type]) {
+ chOffset = getMdEndCh(cellNode[type]) - 1;
+ }
+ else {
+ var row = !parent[type] && parent.parent.type === parentType
+ ? parent.parent[type][childType]
+ : parent[type];
+ if (type === 'next') {
+ // if there is next row, the base offset would be end position of the next row's first child.
+ // Otherwise, the base offset is zero.
+ var baseOffset = row ? getMdEndCh(row[childType]) : 0;
+ // calculate tag(open, close) position('2') for selection
+ chOffset += baseOffset + 2;
+ }
+ else if (type === 'prev') {
+ // if there is prev row, the target position would be '-4' for calculating ' |' characters and tag(open, close)
+ // Otherwise, the target position is zero.
+ chOffset = row ? -4 : 0;
+ }
+ }
+ dispatch(tr.setSelection(createTextSelection(tr, endFromOffset + chOffset)));
+ return true;
+ }
+ return false;
+ };
+ };
+ Table.prototype.addTable = function () {
+ return function (payload) { return function (_a, dispatch) {
+ var selection = _a.selection, tr = _a.tr, schema = _a.schema;
+ var _b = payload, columnCount = _b.columnCount, rowCount = _b.rowCount;
+ var endToOffset = getRangeInfo(selection).endToOffset;
+ var headerRows = createTableHeader(columnCount);
+ var bodyRows = createTableBody(columnCount, rowCount - 1);
+ var rows = __spreadArray(__spreadArray([], headerRows), bodyRows);
+ rows.forEach(function (row) {
+ tr.split(tr.mapping.map(endToOffset)).insert(tr.mapping.map(endToOffset), createTextNode(schema, row));
+ });
+ // should add `4` to selection position considering `| ` text and start block tag length
+ dispatch(tr.setSelection(createTextSelection(tr, endToOffset + 4)));
+ return true;
+ }; };
+ };
+ Table.prototype.commands = function () {
+ return { addTable: this.addTable() };
+ };
+ Table.prototype.keymaps = function () {
+ return {
+ Enter: this.extendTable(),
+ Tab: this.moveTableCell(true),
+ 'Shift-Tab': this.moveTableCell(false),
+ };
+ };
+ return Table;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/thematicBreak.ts
+
+
+
+
+
+var thematicBreakSyntax = '***';
+var ThematicBreak = /** @class */ (function (_super) {
+ __extends(ThematicBreak, _super);
+ function ThematicBreak() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(ThematicBreak.prototype, "name", {
+ get: function () {
+ return 'thematicBreak';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ThematicBreak.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('thematic-break') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ ThematicBreak.prototype.hr = function () {
+ return function () { return function (state, dispatch) {
+ var selection = state.selection, schema = state.schema, tr = state.tr;
+ var _a = getRangeInfo(selection), from = _a.from, to = _a.to, endToOffset = _a.endToOffset;
+ var node = createTextNode(schema, thematicBreakSyntax);
+ tr
+ .split(from)
+ .replaceWith(tr.mapping.map(from), tr.mapping.map(to), node)
+ .split(tr.mapping.map(to)).setSelection(createTextSelection(tr, tr.mapping.map(endToOffset)));
+ dispatch(tr);
+ return true;
+ }; };
+ };
+ ThematicBreak.prototype.commands = function () {
+ return { hr: this.hr() };
+ };
+ ThematicBreak.prototype.keymaps = function () {
+ var lineCommand = this.hr()();
+ return { 'Mod-l': lineCommand, 'Mod-L': lineCommand };
+ };
+ return ThematicBreak;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/listItem.ts
+
+
+
+
+
+
+
+
+
+function cannotBeListNode(_a, line) {
+ var type = _a.type, sourcepos = _a.sourcepos;
+ // eslint-disable-next-line prefer-destructuring
+ var startLine = sourcepos[0][0];
+ return line <= startLine && (type === 'codeBlock' || type === 'heading' || type.match('table'));
+}
+var ListItem = /** @class */ (function (_super) {
+ __extends(ListItem, _super);
+ function ListItem() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(ListItem.prototype, "name", {
+ get: function () {
+ return 'listItem';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(ListItem.prototype, "schema", {
+ get: function () {
+ return {
+ attrs: {
+ odd: { default: false },
+ even: { default: false },
+ listStyle: { default: false },
+ },
+ toDOM: function (_a) {
+ var attrs = _a.attrs;
+ var odd = attrs.odd, even = attrs.even, listStyle = attrs.listStyle;
+ var classNames = 'list-item';
+ if (listStyle) {
+ classNames += '|list-item-style';
+ }
+ if (odd) {
+ classNames += '|list-item-odd';
+ }
+ if (even) {
+ classNames += '|list-item-even';
+ }
+ return ['span', { class: clsWithMdPrefix.apply(void 0, classNames.split('|')) }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ ListItem.prototype.extendList = function () {
+ var _this = this;
+ return function (_a, dispatch) {
+ var selection = _a.selection, doc = _a.doc, schema = _a.schema, tr = _a.tr;
+ var toastMark = _this.context.toastMark;
+ var _b = getRangeInfo(selection), to = _b.to, startFromOffset = _b.startFromOffset, endFromOffset = _b.endFromOffset, endIndex = _b.endIndex, endToOffset = _b.endToOffset;
+ var textContent = getTextContent(doc, endIndex);
+ var isList = reList.test(textContent);
+ if (!isList || selection.from === startFromOffset || !selection.empty) {
+ return false;
+ }
+ var isEmpty = !textContent.replace(reCanBeTaskList, '').trim();
+ if (isEmpty) {
+ tr.deleteRange(endFromOffset, endToOffset).split(tr.mapping.map(endToOffset));
+ }
+ else {
+ var commandType = getListType(textContent);
+ // should add `1` to line for the markdown parser
+ // because markdown parser has `1`(not zero) as the start number
+ var mdNode = toastMark.findFirstNodeAtLine(endIndex + 1);
+ var slicedText = textContent.slice(to - endFromOffset);
+ var context = { toastMark: toastMark, mdNode: mdNode, doc: doc, line: endIndex + 1 };
+ var _c = extendList[commandType](context), listSyntax = _c.listSyntax, changedResults = _c.changedResults;
+ // change ordinal number of backward ordered list
+ if (changedResults === null || changedResults === void 0 ? void 0 : changedResults.length) {
+ // split the block
+ tr.split(to);
+ // set first ordered list info
+ changedResults.unshift({ text: listSyntax + slicedText, line: endIndex + 1 });
+ _this.changeToListPerLine(tr, changedResults, {
+ from: to,
+ // don't subtract 1 because the line has increased through 'split' command.
+ startLine: changedResults[0].line,
+ endLine: last(changedResults).line,
+ });
+ var pos = tr.mapping.map(endToOffset) - slicedText.length;
+ tr.setSelection(createTextSelection(tr, pos));
+ }
+ else {
+ var node = createTextNode(schema, listSyntax + slicedText);
+ splitAndExtendBlock(tr, endToOffset, slicedText, node);
+ }
+ }
+ dispatch(tr);
+ return true;
+ };
+ };
+ ListItem.prototype.toList = function (commandType) {
+ var _this = this;
+ return function () { return function (_a, dispatch) {
+ var doc = _a.doc, tr = _a.tr, selection = _a.selection;
+ var toastMark = _this.context.toastMark;
+ var rangeInfo = getRangeInfo(selection);
+ // should add `1` to line for the markdown parser
+ // because markdown parser has `1`(not zero) as the start number
+ var startLine = rangeInfo.startIndex + 1;
+ var endLine = rangeInfo.endIndex + 1;
+ var endToOffset = rangeInfo.endToOffset;
+ var skipLines = [];
+ for (var line = startLine; line <= endLine; line += 1) {
+ var mdNode = toastMark.findFirstNodeAtLine(line);
+ if (mdNode && cannotBeListNode(mdNode, line)) {
+ break;
+ }
+ // to skip unnecessary processing
+ if (skipLines.indexOf(line) !== -1) {
+ continue;
+ }
+ var context = { toastMark: toastMark, mdNode: mdNode, doc: doc, line: line, startLine: startLine };
+ var changedResults = (isListNode(mdNode)
+ ? otherListToList[commandType](context)
+ : otherNodeToList[commandType](context)).changedResults;
+ var endOffset = _this.changeToListPerLine(tr, changedResults, {
+ from: getNodeContentOffsetRange(doc, changedResults[0].line - 1).startOffset,
+ startLine: changedResults[0].line,
+ endLine: last(changedResults).line,
+ indexDiff: 1,
+ });
+ endToOffset = Math.max(endOffset, endToOffset);
+ if (changedResults) {
+ skipLines = skipLines.concat(changedResults.map(function (info) { return info.line; }));
+ }
+ }
+ dispatch(tr.setSelection(createTextSelection(tr, tr.mapping.map(endToOffset))));
+ return true;
+ }; };
+ };
+ ListItem.prototype.changeToListPerLine = function (tr, changedResults, _a) {
+ var from = _a.from, startLine = _a.startLine, endLine = _a.endLine, _b = _a.indexDiff, indexDiff = _b === void 0 ? 0 : _b;
+ var maxEndOffset = 0;
+ var _loop_1 = function (i) {
+ var _c = tr.doc.child(i), nodeSize = _c.nodeSize, content = _c.content;
+ var mappedFrom = tr.mapping.map(from);
+ var mappedTo = mappedFrom + content.size;
+ var changedResult = changedResults.filter(function (result) { return result.line - indexDiff === i; })[0];
+ if (changedResult) {
+ tr.replaceWith(mappedFrom, mappedTo, createTextNode(this_1.context.schema, changedResult.text));
+ maxEndOffset = Math.max(maxEndOffset, from + content.size);
+ }
+ from += nodeSize;
+ };
+ var this_1 = this;
+ for (var i = startLine - indexDiff; i <= endLine - indexDiff; i += 1) {
+ _loop_1(i);
+ }
+ return maxEndOffset;
+ };
+ ListItem.prototype.toggleTask = function () {
+ var _this = this;
+ return function (_a, dispatch) {
+ var selection = _a.selection, tr = _a.tr, doc = _a.doc, schema = _a.schema;
+ var toastMark = _this.context.toastMark;
+ var _b = getRangeInfo(selection), startIndex = _b.startIndex, endIndex = _b.endIndex;
+ var newTr = null;
+ for (var i = startIndex; i <= endIndex; i += 1) {
+ var mdNode = toastMark.findFirstNodeAtLine(i + 1);
+ if (isListNode(mdNode) && mdNode.listData.task) {
+ var _c = mdNode.listData, checked = _c.checked, padding = _c.padding;
+ var stateChar = checked ? ' ' : 'x';
+ var mdPos = mdNode.sourcepos[0];
+ var startOffset = getNodeContentOffsetRange(doc, mdPos[0] - 1).startOffset;
+ startOffset += mdPos[1] + padding;
+ newTr = tr.replaceWith(startOffset, startOffset + 1, schema.text(stateChar));
+ }
+ }
+ if (newTr) {
+ dispatch(newTr);
+ return true;
+ }
+ return false;
+ };
+ };
+ ListItem.prototype.commands = function () {
+ return {
+ bulletList: this.toList('bullet'),
+ orderedList: this.toList('ordered'),
+ taskList: this.toList('task'),
+ };
+ };
+ ListItem.prototype.keymaps = function () {
+ var bulletCommand = this.toList('bullet')();
+ var orderedCommand = this.toList('ordered')();
+ var taskCommand = this.toList('task')();
+ var togleTaskCommand = this.toggleTask();
+ return {
+ 'Mod-u': bulletCommand,
+ 'Mod-U': bulletCommand,
+ 'Mod-o': orderedCommand,
+ 'Mod-O': orderedCommand,
+ 'alt-t': taskCommand,
+ 'alt-T': taskCommand,
+ 'Shift-Ctrl-x': togleTaskCommand,
+ 'Shift-Ctrl-X': togleTaskCommand,
+ Enter: this.extendList(),
+ };
+ };
+ return ListItem;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/helper/mdCommand.ts
+
+
+
+function mdCommand_toggleMark(condition, syntax) {
+ return function () { return function (_a, dispatch) {
+ var tr = _a.tr, selection = _a.selection;
+ var conditionFn = !isFunction_default()(condition)
+ ? function (text) { return condition.test(text); }
+ : condition;
+ var syntaxLen = syntax.length;
+ var doc = tr.doc;
+ var _b = resolveSelectionPos(selection), from = _b[0], to = _b[1];
+ var prevPos = Math.max(from - syntaxLen, 1);
+ var nextPos = Math.min(to + syntaxLen, doc.content.size - 1);
+ var slice = selection.content();
+ var textContent = slice.content.textBetween(0, slice.content.size, '\n');
+ var prevText = doc.textBetween(prevPos, from, '\n');
+ var nextText = doc.textBetween(to, nextPos, '\n');
+ textContent = "" + prevText + textContent + nextText;
+ if (prevText && nextText && conditionFn(textContent)) {
+ tr.delete(nextPos - syntaxLen, nextPos).delete(prevPos, prevPos + syntaxLen);
+ }
+ else {
+ tr.insertText(syntax, to).insertText(syntax, from);
+ var newSelection = selection.empty
+ ? createTextSelection(tr, from + syntaxLen)
+ : createTextSelection(tr, from + syntaxLen, to + syntaxLen);
+ tr.setSelection(newSelection);
+ }
+ dispatch(tr);
+ return true;
+ }; };
+}
+
+;// CONCATENATED MODULE: ./src/markdown/marks/strong.ts
+
+
+
+
+var reStrong = /^(\*{2}|_{2}).*([\s\S]*)\1$/m;
+var strongSyntax = '**';
+var Strong = /** @class */ (function (_super) {
+ __extends(Strong, _super);
+ function Strong() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Strong.prototype, "name", {
+ get: function () {
+ return 'strong';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Strong.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('strong') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Strong.prototype.bold = function () {
+ return mdCommand_toggleMark(reStrong, strongSyntax);
+ };
+ Strong.prototype.commands = function () {
+ return { bold: this.bold() };
+ };
+ Strong.prototype.keymaps = function () {
+ var boldCommand = this.bold()();
+ return { 'Mod-b': boldCommand, 'Mod-B': boldCommand };
+ };
+ return Strong;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/strike.ts
+
+
+
+
+var reStrike = /^(~{2}).*([\s\S]*)\1$/m;
+var strikeSyntax = '~~';
+var Strike = /** @class */ (function (_super) {
+ __extends(Strike, _super);
+ function Strike() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Strike.prototype, "name", {
+ get: function () {
+ return 'strike';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Strike.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('strike') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Strike.prototype.commands = function () {
+ return mdCommand_toggleMark(reStrike, strikeSyntax);
+ };
+ Strike.prototype.keymaps = function () {
+ var strikeCommand = this.commands()();
+ return { 'Mod-s': strikeCommand, 'Mod-S': strikeCommand };
+ };
+ return Strike;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/emph.ts
+
+
+
+
+var reEmph = /^(\*|_).*([\s\S]*)\1$/m;
+var emphSyntax = '*';
+var Emph = /** @class */ (function (_super) {
+ __extends(Emph, _super);
+ function Emph() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Emph.prototype, "name", {
+ get: function () {
+ return 'emph';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Emph.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('emph') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Emph.prototype.italic = function () {
+ return mdCommand_toggleMark(reEmph, emphSyntax);
+ };
+ Emph.prototype.commands = function () {
+ return { italic: this.italic() };
+ };
+ Emph.prototype.keymaps = function () {
+ var italicCommand = this.italic()();
+ return { 'Mod-i': italicCommand, 'Mod-I': italicCommand };
+ };
+ return Emph;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/code.ts
+
+
+
+
+var reCode = /^(`).*([\s\S]*)\1$/m;
+var codeSyntax = '`';
+var Code = /** @class */ (function (_super) {
+ __extends(Code, _super);
+ function Code() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Code.prototype, "name", {
+ get: function () {
+ return 'code';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Code.prototype, "schema", {
+ get: function () {
+ return {
+ attrs: {
+ start: { default: false },
+ end: { default: false },
+ marked: { default: false },
+ },
+ toDOM: function (mark) {
+ var _a = mark.attrs, start = _a.start, end = _a.end, marked = _a.marked;
+ var classNames = 'code';
+ if (start) {
+ classNames += '|delimiter|start';
+ }
+ if (end) {
+ classNames += '|delimiter|end';
+ }
+ if (marked) {
+ classNames += '|marked-text';
+ }
+ return ['span', { class: clsWithMdPrefix.apply(void 0, classNames.split('|')) }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Code.prototype.commands = function () {
+ return mdCommand_toggleMark(reCode, codeSyntax);
+ };
+ Code.prototype.keymaps = function () {
+ var codeCommand = this.commands()();
+ return { 'Shift-Mod-c': codeCommand, 'Shift-Mod-C': codeCommand };
+ };
+ return Code;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/link.ts
+
+
+
+
+
+
+var Link = /** @class */ (function (_super) {
+ __extends(Link, _super);
+ function Link() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Link.prototype, "name", {
+ get: function () {
+ return 'link';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Link.prototype, "schema", {
+ get: function () {
+ return {
+ attrs: {
+ url: { default: false },
+ desc: { default: false },
+ },
+ toDOM: function (_a) {
+ var attrs = _a.attrs;
+ var url = attrs.url, desc = attrs.desc;
+ var classNames = 'link';
+ if (url) {
+ classNames += '|link-url|marked-text';
+ }
+ if (desc) {
+ classNames += '|link-desc|marked-text';
+ }
+ return ['span', { class: clsWithMdPrefix.apply(void 0, classNames.split('|')) }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Link.prototype.addLinkOrImage = function (commandType) {
+ return function (payload) { return function (_a, dispatch) {
+ var selection = _a.selection, tr = _a.tr, schema = _a.schema;
+ var _b = resolveSelectionPos(selection), from = _b[0], to = _b[1];
+ var _c = payload, linkText = _c.linkText, altText = _c.altText, linkUrl = _c.linkUrl, imageUrl = _c.imageUrl;
+ var text = linkText;
+ var url = linkUrl;
+ var syntax = '';
+ if (commandType === 'image') {
+ text = altText;
+ url = imageUrl;
+ syntax = '!';
+ }
+ text = escapeTextForLink(text);
+ syntax += "[" + text + "](" + url + ")";
+ dispatch(tr.replaceWith(from, to, createTextNode(schema, syntax)));
+ return true;
+ }; };
+ };
+ Link.prototype.commands = function () {
+ return {
+ addImage: this.addLinkOrImage('image'),
+ addLink: this.addLinkOrImage('link'),
+ };
+ };
+ return Link;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/simpleMark.ts
+
+
+
+var TaskDelimiter = /** @class */ (function (_super) {
+ __extends(TaskDelimiter, _super);
+ function TaskDelimiter() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(TaskDelimiter.prototype, "name", {
+ get: function () {
+ return 'taskDelimiter';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(TaskDelimiter.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('delimiter', 'list-item') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return TaskDelimiter;
+}(mark));
+
+var Delimiter = /** @class */ (function (_super) {
+ __extends(Delimiter, _super);
+ function Delimiter() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Delimiter.prototype, "name", {
+ get: function () {
+ return 'delimiter';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Delimiter.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('delimiter') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return Delimiter;
+}(mark));
+
+var Meta = /** @class */ (function (_super) {
+ __extends(Meta, _super);
+ function Meta() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Meta.prototype, "name", {
+ get: function () {
+ return 'meta';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Meta.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('meta') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return Meta;
+}(mark));
+
+var MarkedText = /** @class */ (function (_super) {
+ __extends(MarkedText, _super);
+ function MarkedText() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(MarkedText.prototype, "name", {
+ get: function () {
+ return 'markedText';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(MarkedText.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('marked-text') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return MarkedText;
+}(mark));
+
+var TableCell = /** @class */ (function (_super) {
+ __extends(TableCell, _super);
+ function TableCell() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(TableCell.prototype, "name", {
+ get: function () {
+ return 'tableCell';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(TableCell.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('table-cell') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return TableCell;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/html.ts
+
+
+
+var Html = /** @class */ (function (_super) {
+ __extends(Html, _super);
+ function Html() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(Html.prototype, "name", {
+ get: function () {
+ return 'html';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(Html.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('html') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ return Html;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/marks/customBlock.ts
+
+
+
+
+
+var customBlockSyntax = '$$';
+var CustomBlock = /** @class */ (function (_super) {
+ __extends(CustomBlock, _super);
+ function CustomBlock() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Object.defineProperty(CustomBlock.prototype, "name", {
+ get: function () {
+ return 'customBlock';
+ },
+ enumerable: false,
+ configurable: true
+ });
+ Object.defineProperty(CustomBlock.prototype, "schema", {
+ get: function () {
+ return {
+ toDOM: function () {
+ return ['span', { class: clsWithMdPrefix('custom-block') }, 0];
+ },
+ };
+ },
+ enumerable: false,
+ configurable: true
+ });
+ CustomBlock.prototype.commands = function () {
+ return function (payload) { return function (state, dispatch) {
+ var selection = state.selection, schema = state.schema, tr = state.tr;
+ var _a = getRangeInfo(selection), startFromOffset = _a.startFromOffset, endToOffset = _a.endToOffset;
+ if (!(payload === null || payload === void 0 ? void 0 : payload.info)) {
+ return false;
+ }
+ var customBlock = "" + customBlockSyntax + payload.info;
+ var startNode = createTextNode(schema, customBlock);
+ var endNode = createTextNode(schema, customBlockSyntax);
+ tr.insert(startFromOffset, startNode).split(startFromOffset + customBlock.length);
+ tr.split(tr.mapping.map(endToOffset)).insert(tr.mapping.map(endToOffset), endNode);
+ dispatch(tr.setSelection(createTextSelection(tr, tr.mapping.map(endToOffset) - (customBlockSyntax.length + 2))));
+ return true;
+ }; };
+ };
+ return CustomBlock;
+}(mark));
+
+
+;// CONCATENATED MODULE: ./src/markdown/plugins/smartTask.ts
+
+
+
+var reTaskMarkerKey = /x|backspace/i;
+var reTaskMarker = /^\[(\s*)(x?)(\s*)\](?:\s+)/i;
+function smartTask(_a) {
+ var schema = _a.schema, toastMark = _a.toastMark;
+ return new Plugin({
+ props: {
+ handleDOMEvents: {
+ keyup: function (view, ev) {
+ var _a;
+ var _b = view.state, doc = _b.doc, tr = _b.tr, selection = _b.selection;
+ if (selection.empty && reTaskMarkerKey.test(ev.key)) {
+ var _c = getRangeInfo(selection), startIndex = _c.startIndex, startFromOffset = _c.startFromOffset, from = _c.from;
+ // should add `1` to line for the markdown parser
+ // because markdown parser has `1`(not zero) as the start number
+ var mdPos = [startIndex + 1, from - startFromOffset + 1];
+ var mdNode = toastMark.findNodeAtPosition(mdPos);
+ var paraNode = findClosestNode(mdNode, function (node) { var _a; return node.type === 'paragraph' && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === 'item'; });
+ if ((_a = paraNode === null || paraNode === void 0 ? void 0 : paraNode.firstChild) === null || _a === void 0 ? void 0 : _a.literal) {
+ var firstChild = paraNode.firstChild;
+ var matched = firstChild.literal.match(reTaskMarker);
+ if (matched) {
+ var startMdPos = firstChild.sourcepos[0];
+ var startSpaces = matched[1], stateChar = matched[2], lastSpaces = matched[3];
+ var spaces = startSpaces.length + lastSpaces.length;
+ var startOffset = getNodeContentOffsetRange(doc, startMdPos[0] - 1).startOffset;
+ var startPos = startMdPos[1] + startOffset;
+ if (stateChar) {
+ var addedPos = spaces ? spaces + 1 : 0;
+ tr.replaceWith(startPos, addedPos + startPos, schema.text(stateChar));
+ view.dispatch(tr);
+ }
+ else if (!spaces) {
+ tr.insertText(' ', startPos);
+ view.dispatch(tr);
+ }
+ }
+ }
+ }
+ return false;
+ },
+ },
+ },
+ });
+}
+
+;// CONCATENATED MODULE: ./src/markdown/mdEditor.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var EVENT_TYPE = 'cut';
+var reLineEnding = /\r\n|\n|\r/;
+var MdEditor = /** @class */ (function (_super) {
+ __extends(MdEditor, _super);
+ function MdEditor(eventEmitter, options) {
+ var _this = _super.call(this, eventEmitter) || this;
+ var toastMark = options.toastMark, _a = options.useCommandShortcut, useCommandShortcut = _a === void 0 ? true : _a, _b = options.mdPlugins, mdPlugins = _b === void 0 ? [] : _b;
+ _this.editorType = 'markdown';
+ _this.el.classList.add('md-mode');
+ _this.toastMark = toastMark;
+ _this.extraPlugins = mdPlugins;
+ _this.specs = _this.createSpecs();
+ _this.schema = _this.createSchema();
+ _this.context = _this.createContext();
+ _this.keymaps = _this.createKeymaps(useCommandShortcut);
+ _this.view = _this.createView();
+ _this.commands = _this.createCommands();
+ _this.specs.setContext(__assign(__assign({}, _this.context), { view: _this.view }));
+ _this.createClipboard();
+ // To prevent unnecessary focus setting during initial rendering
+ _this.eventEmitter.listen('changePreviewTabWrite', function (isMarkdownTabMounted) {
+ return _this.toggleActive(true, isMarkdownTabMounted);
+ });
+ _this.eventEmitter.listen('changePreviewTabPreview', function () { return _this.toggleActive(false); });
+ _this.initEvent();
+ return _this;
+ }
+ MdEditor.prototype.toggleActive = function (active, isMarkdownTabMounted) {
+ toggleClass(this.el, 'active', active);
+ if (active) {
+ if (!isMarkdownTabMounted) {
+ this.focus();
+ }
+ }
+ else {
+ this.blur();
+ }
+ };
+ MdEditor.prototype.createClipboard = function () {
+ var _this = this;
+ this.clipboard = document.createElement('textarea');
+ this.clipboard.className = cls('pseudo-clipboard');
+ this.clipboard.addEventListener('paste', function (ev) {
+ var clipboardData = ev.clipboardData || window.clipboardData;
+ var items = clipboardData && clipboardData.items;
+ if (items) {
+ var containRtfItem = toArray_default()(items).some(function (item) { return item.kind === 'string' && item.type === 'text/rtf'; });
+ // if it contains rtf, it's most likely copy paste from office -> no image
+ if (!containRtfItem) {
+ var imageBlob = pasteImageOnly(items);
+ if (imageBlob) {
+ ev.preventDefault();
+ emitImageBlobHook(_this.eventEmitter, imageBlob, ev.type);
+ }
+ }
+ }
+ });
+ // process the pasted data in input event for IE11
+ this.clipboard.addEventListener('input', function (ev) {
+ var text = ev.target.value;
+ _this.replaceSelection(text);
+ ev.preventDefault();
+ ev.target.value = '';
+ });
+ this.el.insertBefore(this.clipboard, this.view.dom);
+ };
+ MdEditor.prototype.createContext = function () {
+ return {
+ toastMark: this.toastMark,
+ schema: this.schema,
+ eventEmitter: this.eventEmitter,
+ };
+ };
+ MdEditor.prototype.createSpecs = function () {
+ return new specManager([
+ new Doc(),
+ new Paragraph(),
+ new Widget(),
+ new Text(),
+ new Heading(),
+ new BlockQuote(),
+ new CodeBlock(),
+ new CustomBlock(),
+ new Table(),
+ new TableCell(),
+ new ThematicBreak(),
+ new ListItem(),
+ new Strong(),
+ new Strike(),
+ new Emph(),
+ new Code(),
+ new Link(),
+ new Delimiter(),
+ new TaskDelimiter(),
+ new MarkedText(),
+ new Meta(),
+ new Html(),
+ ]);
+ };
+ MdEditor.prototype.createPlugins = function () {
+ return __spreadArray([
+ syntaxHighlight(this.context),
+ previewHighlight(this.context),
+ smartTask(this.context)
+ ], this.createPluginProps()).concat(this.defaultPlugins);
+ };
+ MdEditor.prototype.createView = function () {
+ var _this = this;
+ return new EditorView(this.el, {
+ state: this.createState(),
+ dispatchTransaction: function (tr) {
+ _this.updateMarkdown(tr);
+ var state = _this.view.state.applyTransaction(tr).state;
+ _this.view.updateState(state);
+ _this.emitChangeEvent(tr);
+ },
+ handleKeyDown: function (_, ev) {
+ if ((ev.metaKey || ev.ctrlKey) && ev.key.toUpperCase() === 'V') {
+ _this.clipboard.focus();
+ }
+ _this.eventEmitter.emit('keydown', _this.editorType, ev);
+ return false;
+ },
+ handleDOMEvents: {
+ copy: function (_, ev) { return _this.captureCopy(ev); },
+ cut: function (_, ev) { return _this.captureCopy(ev, EVENT_TYPE); },
+ scroll: function () {
+ _this.eventEmitter.emit('scroll', 'editor');
+ return true;
+ },
+ keyup: function (_, ev) {
+ _this.eventEmitter.emit('keyup', _this.editorType, ev);
+ return false;
+ },
+ },
+ nodeViews: {
+ widget: widgetNodeView,
+ },
+ });
+ };
+ MdEditor.prototype.createCommands = function () {
+ return this.specs.commands(this.view);
+ };
+ MdEditor.prototype.captureCopy = function (ev, type) {
+ ev.preventDefault();
+ var _a = this.view.state, selection = _a.selection, tr = _a.tr;
+ if (selection.empty) {
+ return true;
+ }
+ var text = this.getChanged(selection.content());
+ if (ev.clipboardData) {
+ ev.clipboardData.setData('text/plain', text);
+ }
+ else {
+ window.clipboardData.setData('Text', text);
+ }
+ if (type === EVENT_TYPE) {
+ this.view.dispatch(tr.deleteSelection().scrollIntoView().setMeta('uiEvent', EVENT_TYPE));
+ }
+ return true;
+ };
+ MdEditor.prototype.updateMarkdown = function (tr) {
+ var _this = this;
+ if (tr.docChanged) {
+ tr.steps.forEach(function (step, index) {
+ if (step.slice && !(step instanceof ReplaceAroundStep)) {
+ var doc = tr.docs[index];
+ var _a = [step.from, step.to], from = _a[0], to = _a[1];
+ var _b = getEditorToMdPos(doc, from, to), startPos = _b[0], endPos = _b[1];
+ var changed = _this.getChanged(step.slice);
+ if (startPos[0] === endPos[0] && startPos[1] === endPos[1] && changed === '') {
+ changed = '\n';
+ }
+ var editResult = _this.toastMark.editMarkdown(startPos, endPos, changed);
+ _this.eventEmitter.emit('updatePreview', editResult);
+ tr.setMeta('editResult', editResult).scrollIntoView();
+ }
+ });
+ }
+ };
+ MdEditor.prototype.getChanged = function (slice) {
+ var changed = '';
+ var from = 0;
+ var to = slice.content.size;
+ slice.content.nodesBetween(from, to, function (node, pos) {
+ if (node.isText) {
+ changed += node.text.slice(Math.max(from, pos) - pos, to - pos);
+ }
+ else if (node.isBlock && pos > 0) {
+ changed += '\n';
+ }
+ });
+ return changed;
+ };
+ MdEditor.prototype.setSelection = function (start, end) {
+ if (end === void 0) { end = start; }
+ var tr = this.view.state.tr;
+ var _a = getMdToEditorPos(tr.doc, start, end), from = _a[0], to = _a[1];
+ this.view.dispatch(tr.setSelection(createTextSelection(tr, from, to)).scrollIntoView());
+ };
+ MdEditor.prototype.replaceSelection = function (text, start, end) {
+ var newTr;
+ var _a = this.view.state, tr = _a.tr, schema = _a.schema, doc = _a.doc;
+ var lineTexts = text.split(reLineEnding);
+ var nodes = lineTexts.map(function (lineText) {
+ return createParagraph(schema, createNodesWithWidget(lineText, schema));
+ });
+ var slice = new Slice(Fragment.from(nodes), 1, 1);
+ this.focus();
+ if (start && end) {
+ var _b = getMdToEditorPos(doc, start, end), from = _b[0], to = _b[1];
+ newTr = tr.replaceRange(from, to, slice);
+ }
+ else {
+ newTr = tr.replaceSelection(slice);
+ }
+ this.view.dispatch(newTr.scrollIntoView());
+ };
+ MdEditor.prototype.deleteSelection = function (start, end) {
+ var newTr;
+ var _a = this.view.state, tr = _a.tr, doc = _a.doc;
+ if (start && end) {
+ var _b = getMdToEditorPos(doc, start, end), from = _b[0], to = _b[1];
+ newTr = tr.deleteRange(from, to);
+ }
+ else {
+ newTr = tr.deleteSelection();
+ }
+ this.view.dispatch(newTr.scrollIntoView());
+ };
+ MdEditor.prototype.getSelectedText = function (start, end) {
+ var _a = this.view.state, doc = _a.doc, selection = _a.selection;
+ var from = selection.from, to = selection.to;
+ if (start && end) {
+ var pos = getMdToEditorPos(doc, start, end);
+ from = pos[0];
+ to = pos[1];
+ }
+ return doc.textBetween(from, to, '\n');
+ };
+ MdEditor.prototype.getSelection = function () {
+ var _a = this.view.state.selection, from = _a.from, to = _a.to;
+ return getEditorToMdPos(this.view.state.tr.doc, from, to);
+ };
+ MdEditor.prototype.setMarkdown = function (markdown, cursorToEnd) {
+ if (cursorToEnd === void 0) { cursorToEnd = true; }
+ var lineTexts = markdown.split(reLineEnding);
+ var _a = this.view.state, tr = _a.tr, doc = _a.doc, schema = _a.schema;
+ var nodes = lineTexts.map(function (lineText) {
+ return createParagraph(schema, createNodesWithWidget(lineText, schema));
+ });
+ this.view.dispatch(tr.replaceWith(0, doc.content.size, nodes));
+ if (cursorToEnd) {
+ this.moveCursorToEnd(true);
+ }
+ };
+ MdEditor.prototype.addWidget = function (node, style, mdPos) {
+ var _a = this.view.state, tr = _a.tr, doc = _a.doc, selection = _a.selection;
+ var pos = mdPos ? getMdToEditorPos(doc, mdPos, mdPos)[0] : selection.to;
+ this.view.dispatch(tr.setMeta('widget', { pos: pos, node: node, style: style }));
+ };
+ MdEditor.prototype.replaceWithWidget = function (start, end, text) {
+ var _a = this.view.state, tr = _a.tr, schema = _a.schema, doc = _a.doc;
+ var pos = getMdToEditorPos(doc, start, end);
+ var nodes = createNodesWithWidget(text, schema);
+ this.view.dispatch(tr.replaceWith(pos[0], pos[1], nodes));
+ };
+ MdEditor.prototype.getRangeInfoOfNode = function (pos) {
+ var _a = this.view.state, doc = _a.doc, selection = _a.selection;
+ var mdPos = pos || getEditorToMdPos(doc, selection.from)[0];
+ var mdNode = this.toastMark.findNodeAtPosition(mdPos);
+ if (mdNode.type === 'text' && mdNode.parent.type !== 'paragraph') {
+ mdNode = mdNode.parent;
+ }
+ // add 1 sync for prosemirror position
+ mdNode.sourcepos[1][1] += 1;
+ return { range: mdNode.sourcepos, type: mdNode.type };
+ };
+ MdEditor.prototype.getMarkdown = function () {
+ return this.toastMark
+ .getLineTexts()
+ .map(function (lineText) { return unwrapWidgetSyntax(lineText); })
+ .join('\n');
+ };
+ MdEditor.prototype.getToastMark = function () {
+ return this.toastMark;
+ };
+ return MdEditor;
+}(src_base));
+/* harmony default export */ var mdEditor = (MdEditor);
+
+// EXTERNAL MODULE: ../../node_modules/tui-code-snippet/domEvent/off.js
+var off = __webpack_require__(349);
+var off_default = /*#__PURE__*/__webpack_require__.n(off);
+// EXTERNAL MODULE: ../../node_modules/tui-code-snippet/domEvent/on.js
+var on = __webpack_require__(348);
+var on_default = /*#__PURE__*/__webpack_require__.n(on);
+;// CONCATENATED MODULE: ../../libs/toastmark/dist/esm/index.js
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+var esm_extendStatics = function (d, b) {
+ esm_extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b)
+ if (Object.prototype.hasOwnProperty.call(b, p))
+ d[p] = b[p]; };
+ return esm_extendStatics(d, b);
+};
+function esm_extends(d, b) {
+ if (typeof b !== "function" && b !== null)
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+ esm_extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var esm_assign = function () {
+ esm_assign = Object.assign || function __assign(t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+ for (var p in s)
+ if (Object.prototype.hasOwnProperty.call(s, p))
+ t[p] = s[p];
+ }
+ return t;
+ };
+ return esm_assign.apply(this, arguments);
+};
+function esm_spreadArray(to, from, pack) {
+ if (pack || arguments.length === 2)
+ for (var i = 0, l = from.length, ar; i < l; i++) {
+ if (ar || !(i in from)) {
+ if (!ar)
+ ar = Array.prototype.slice.call(from, 0, i);
+ ar[i] = from[i];
+ }
+ }
+ return to.concat(ar || Array.prototype.slice.call(from));
+}
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof self !== 'undefined' ? self : {};
+var encodeCache = {};
+// Create a lookup array where anything but characters in `chars` string
+// and alphanumeric chars is percent-encoded.
+//
+function getEncodeCache(exclude) {
+ var i, ch, cache = encodeCache[exclude];
+ if (cache) {
+ return cache;
+ }
+ cache = encodeCache[exclude] = [];
+ for (i = 0; i < 128; i++) {
+ ch = String.fromCharCode(i);
+ if (/^[0-9a-z]$/i.test(ch)) {
+ // always allow unencoded alphanumeric characters
+ cache.push(ch);
+ }
+ else {
+ cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));
+ }
+ }
+ for (i = 0; i < exclude.length; i++) {
+ cache[exclude.charCodeAt(i)] = exclude[i];
+ }
+ return cache;
+}
+// Encode unsafe characters with percent-encoding, skipping already
+// encoded sequences.
+//
+// - string - string to encode
+// - exclude - list of characters to ignore (in addition to a-zA-Z0-9)
+// - keepEscaped - don't encode '%' in a correct escape sequence (default: true)
+//
+function encode$1(string, exclude, keepEscaped) {
+ var i, l, code, nextCode, cache, result = '';
+ if (typeof exclude !== 'string') {
+ // encode(string, keepEscaped)
+ keepEscaped = exclude;
+ exclude = encode$1.defaultChars;
+ }
+ if (typeof keepEscaped === 'undefined') {
+ keepEscaped = true;
+ }
+ cache = getEncodeCache(exclude);
+ for (i = 0, l = string.length; i < l; i++) {
+ code = string.charCodeAt(i);
+ if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {
+ if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
+ result += string.slice(i, i + 3);
+ i += 2;
+ continue;
+ }
+ }
+ if (code < 128) {
+ result += cache[code];
+ continue;
+ }
+ if (code >= 0xD800 && code <= 0xDFFF) {
+ if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {
+ nextCode = string.charCodeAt(i + 1);
+ if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
+ result += encodeURIComponent(string[i] + string[i + 1]);
+ i++;
+ continue;
+ }
+ }
+ result += '%EF%BF%BD';
+ continue;
+ }
+ result += encodeURIComponent(string[i]);
+ }
+ return result;
+}
+encode$1.defaultChars = ";/?:@&=+$,-_.!~*'()#";
+encode$1.componentChars = "-_.!~*'()";
+var encode_1 = encode$1;
+var lib = {};
+var decode = {};
+var Aacute$1 = "Á";
+var aacute$1 = "á";
+var Abreve = "Ă";
+var abreve = "ă";
+var ac = "∾";
+var acd = "∿";
+var acE = "∾̳";
+var Acirc$1 = "Â";
+var acirc$1 = "â";
+var acute$1 = "´";
+var Acy = "А";
+var acy = "а";
+var AElig$1 = "Æ";
+var aelig$1 = "æ";
+var af = "";
+var Afr = "𝔄";
+var afr = "𝔞";
+var Agrave$1 = "À";
+var agrave$1 = "à";
+var alefsym = "ℵ";
+var aleph = "ℵ";
+var Alpha = "Α";
+var alpha = "α";
+var Amacr = "Ā";
+var amacr = "ā";
+var amalg = "⨿";
+var amp$2 = "&";
+var AMP$1 = "&";
+var andand = "⩕";
+var And = "⩓";
+var and = "∧";
+var andd = "⩜";
+var andslope = "⩘";
+var andv = "⩚";
+var ang = "∠";
+var ange = "⦤";
+var angle = "∠";
+var angmsdaa = "⦨";
+var angmsdab = "⦩";
+var angmsdac = "⦪";
+var angmsdad = "⦫";
+var angmsdae = "⦬";
+var angmsdaf = "⦭";
+var angmsdag = "⦮";
+var angmsdah = "⦯";
+var angmsd = "∡";
+var angrt = "∟";
+var angrtvb = "⊾";
+var angrtvbd = "⦝";
+var angsph = "∢";
+var angst = "Å";
+var angzarr = "⍼";
+var Aogon = "Ą";
+var aogon = "ą";
+var Aopf = "𝔸";
+var aopf = "𝕒";
+var apacir = "⩯";
+var ap = "≈";
+var apE = "⩰";
+var ape = "≊";
+var apid = "≋";
+var apos$1 = "'";
+var ApplyFunction = "";
+var approx = "≈";
+var approxeq = "≊";
+var Aring$1 = "Å";
+var aring$1 = "å";
+var Ascr = "𝒜";
+var ascr = "𝒶";
+var Assign = "≔";
+var ast = "*";
+var asymp = "≈";
+var asympeq = "≍";
+var Atilde$1 = "Ã";
+var atilde$1 = "ã";
+var Auml$1 = "Ä";
+var auml$1 = "ä";
+var awconint = "∳";
+var awint = "⨑";
+var backcong = "≌";
+var backepsilon = "϶";
+var backprime = "‵";
+var backsim = "∽";
+var backsimeq = "⋍";
+var Backslash = "∖";
+var Barv = "⫧";
+var barvee = "⊽";
+var barwed = "⌅";
+var Barwed = "⌆";
+var barwedge = "⌅";
+var bbrk = "⎵";
+var bbrktbrk = "⎶";
+var bcong = "≌";
+var Bcy = "Б";
+var bcy = "б";
+var bdquo = "„";
+var becaus = "∵";
+var because = "∵";
+var Because = "∵";
+var bemptyv = "⦰";
+var bepsi = "϶";
+var bernou = "ℬ";
+var Bernoullis = "ℬ";
+var Beta = "Β";
+var beta = "β";
+var beth = "ℶ";
+var esm_between = "≬";
+var Bfr = "𝔅";
+var bfr = "𝔟";
+var bigcap = "⋂";
+var bigcirc = "◯";
+var bigcup = "⋃";
+var bigodot = "⨀";
+var bigoplus = "⨁";
+var bigotimes = "⨂";
+var bigsqcup = "⨆";
+var bigstar = "★";
+var bigtriangledown = "▽";
+var bigtriangleup = "△";
+var biguplus = "⨄";
+var bigvee = "⋁";
+var bigwedge = "⋀";
+var bkarow = "⤍";
+var blacklozenge = "⧫";
+var blacksquare = "▪";
+var blacktriangle = "▴";
+var blacktriangledown = "▾";
+var blacktriangleleft = "◂";
+var blacktriangleright = "▸";
+var blank = "␣";
+var blk12 = "▒";
+var blk14 = "░";
+var blk34 = "▓";
+var block = "█";
+var bne = "=⃥";
+var bnequiv = "≡⃥";
+var bNot = "⫭";
+var bnot = "⌐";
+var Bopf = "𝔹";
+var bopf = "𝕓";
+var bot = "⊥";
+var bottom = "⊥";
+var bowtie = "⋈";
+var boxbox = "⧉";
+var boxdl = "┐";
+var boxdL = "╕";
+var boxDl = "╖";
+var boxDL = "╗";
+var boxdr = "┌";
+var boxdR = "╒";
+var boxDr = "╓";
+var boxDR = "╔";
+var boxh = "─";
+var boxH = "═";
+var boxhd = "┬";
+var boxHd = "╤";
+var boxhD = "╥";
+var boxHD = "╦";
+var boxhu = "┴";
+var boxHu = "╧";
+var boxhU = "╨";
+var boxHU = "╩";
+var boxminus = "⊟";
+var boxplus = "⊞";
+var boxtimes = "⊠";
+var boxul = "┘";
+var boxuL = "╛";
+var boxUl = "╜";
+var boxUL = "╝";
+var boxur = "└";
+var boxuR = "╘";
+var boxUr = "╙";
+var boxUR = "╚";
+var boxv = "│";
+var boxV = "║";
+var boxvh = "┼";
+var boxvH = "╪";
+var boxVh = "╫";
+var boxVH = "╬";
+var boxvl = "┤";
+var boxvL = "╡";
+var boxVl = "╢";
+var boxVL = "╣";
+var boxvr = "├";
+var boxvR = "╞";
+var boxVr = "╟";
+var boxVR = "╠";
+var bprime = "‵";
+var breve = "˘";
+var Breve = "˘";
+var brvbar$1 = "¦";
+var bscr = "𝒷";
+var Bscr = "ℬ";
+var bsemi = "⁏";
+var bsim = "∽";
+var bsime = "⋍";
+var bsolb = "⧅";
+var bsol = "\\";
+var bsolhsub = "⟈";
+var bull = "•";
+var bullet = "•";
+var bump = "≎";
+var bumpE = "⪮";
+var bumpe = "≏";
+var Bumpeq = "≎";
+var bumpeq = "≏";
+var Cacute = "Ć";
+var cacute = "ć";
+var capand = "⩄";
+var capbrcup = "⩉";
+var capcap = "⩋";
+var cap = "∩";
+var Cap = "⋒";
+var capcup = "⩇";
+var capdot = "⩀";
+var CapitalDifferentialD = "ⅅ";
+var caps = "∩︀";
+var caret = "⁁";
+var caron = "ˇ";
+var Cayleys = "ℭ";
+var ccaps = "⩍";
+var Ccaron = "Č";
+var ccaron = "č";
+var Ccedil$1 = "Ç";
+var ccedil$1 = "ç";
+var Ccirc = "Ĉ";
+var ccirc = "ĉ";
+var Cconint = "∰";
+var ccups = "⩌";
+var ccupssm = "⩐";
+var Cdot = "Ċ";
+var cdot = "ċ";
+var cedil$1 = "¸";
+var Cedilla = "¸";
+var cemptyv = "⦲";
+var cent$1 = "¢";
+var centerdot = "·";
+var CenterDot = "·";
+var cfr = "𝔠";
+var Cfr = "ℭ";
+var CHcy = "Ч";
+var chcy = "ч";
+var check = "✓";
+var checkmark = "✓";
+var Chi = "Χ";
+var chi = "χ";
+var circ = "ˆ";
+var circeq = "≗";
+var circlearrowleft = "↺";
+var circlearrowright = "↻";
+var circledast = "⊛";
+var circledcirc = "⊚";
+var circleddash = "⊝";
+var CircleDot = "⊙";
+var circledR = "®";
+var circledS = "Ⓢ";
+var CircleMinus = "⊖";
+var CirclePlus = "⊕";
+var CircleTimes = "⊗";
+var cir = "○";
+var cirE = "⧃";
+var cire = "≗";
+var cirfnint = "⨐";
+var cirmid = "⫯";
+var cirscir = "⧂";
+var ClockwiseContourIntegral = "∲";
+var CloseCurlyDoubleQuote = "”";
+var CloseCurlyQuote = "’";
+var clubs = "♣";
+var clubsuit = "♣";
+var colon = ":";
+var Colon = "∷";
+var Colone = "⩴";
+var colone = "≔";
+var coloneq = "≔";
+var comma = ",";
+var commat = "@";
+var comp = "∁";
+var compfn = "∘";
+var complement = "∁";
+var complexes = "ℂ";
+var cong = "≅";
+var congdot = "⩭";
+var Congruent = "≡";
+var conint = "∮";
+var Conint = "∯";
+var ContourIntegral = "∮";
+var copf = "𝕔";
+var Copf = "ℂ";
+var coprod = "∐";
+var Coproduct = "∐";
+var copy$1 = "©";
+var COPY$1 = "©";
+var copysr = "℗";
+var CounterClockwiseContourIntegral = "∳";
+var crarr = "↵";
+var cross = "✗";
+var Cross = "⨯";
+var Cscr = "𝒞";
+var cscr = "𝒸";
+var csub = "⫏";
+var csube = "⫑";
+var csup = "⫐";
+var csupe = "⫒";
+var ctdot = "⋯";
+var cudarrl = "⤸";
+var cudarrr = "⤵";
+var cuepr = "⋞";
+var cuesc = "⋟";
+var cularr = "↶";
+var cularrp = "⤽";
+var cupbrcap = "⩈";
+var cupcap = "⩆";
+var CupCap = "≍";
+var cup = "∪";
+var Cup = "⋓";
+var cupcup = "⩊";
+var cupdot = "⊍";
+var cupor = "⩅";
+var cups = "∪︀";
+var curarr = "↷";
+var curarrm = "⤼";
+var curlyeqprec = "⋞";
+var curlyeqsucc = "⋟";
+var curlyvee = "⋎";
+var curlywedge = "⋏";
+var curren$1 = "¤";
+var curvearrowleft = "↶";
+var curvearrowright = "↷";
+var cuvee = "⋎";
+var cuwed = "⋏";
+var cwconint = "∲";
+var cwint = "∱";
+var cylcty = "⌭";
+var dagger = "†";
+var Dagger = "‡";
+var daleth = "ℸ";
+var darr = "↓";
+var Darr = "↡";
+var dArr = "⇓";
+var dash = "‐";
+var Dashv = "⫤";
+var dashv = "⊣";
+var dbkarow = "⤏";
+var dblac = "˝";
+var Dcaron = "Ď";
+var dcaron = "ď";
+var Dcy = "Д";
+var dcy = "д";
+var ddagger = "‡";
+var ddarr = "⇊";
+var DD = "ⅅ";
+var dd = "ⅆ";
+var DDotrahd = "⤑";
+var ddotseq = "⩷";
+var deg$1 = "°";
+var Del = "∇";
+var Delta = "Δ";
+var delta = "δ";
+var demptyv = "⦱";
+var dfisht = "⥿";
+var Dfr = "𝔇";
+var dfr = "𝔡";
+var dHar = "⥥";
+var dharl = "⇃";
+var dharr = "⇂";
+var DiacriticalAcute = "´";
+var DiacriticalDot = "˙";
+var DiacriticalDoubleAcute = "˝";
+var DiacriticalGrave = "`";
+var DiacriticalTilde = "˜";
+var diam = "⋄";
+var diamond = "⋄";
+var Diamond = "⋄";
+var diamondsuit = "♦";
+var diams = "♦";
+var die = "¨";
+var DifferentialD = "ⅆ";
+var digamma = "ϝ";
+var disin = "⋲";
+var div = "÷";
+var divide$1 = "÷";
+var divideontimes = "⋇";
+var divonx = "⋇";
+var DJcy = "Ђ";
+var djcy = "ђ";
+var dlcorn = "⌞";
+var dlcrop = "⌍";
+var dollar = "$";
+var Dopf = "𝔻";
+var dopf = "𝕕";
+var Dot = "¨";
+var dot = "˙";
+var DotDot = "⃜";
+var doteq = "≐";
+var doteqdot = "≑";
+var DotEqual = "≐";
+var dotminus = "∸";
+var dotplus = "∔";
+var dotsquare = "⊡";
+var doublebarwedge = "⌆";
+var DoubleContourIntegral = "∯";
+var DoubleDot = "¨";
+var DoubleDownArrow = "⇓";
+var DoubleLeftArrow = "⇐";
+var DoubleLeftRightArrow = "⇔";
+var DoubleLeftTee = "⫤";
+var DoubleLongLeftArrow = "⟸";
+var DoubleLongLeftRightArrow = "⟺";
+var DoubleLongRightArrow = "⟹";
+var DoubleRightArrow = "⇒";
+var DoubleRightTee = "⊨";
+var DoubleUpArrow = "⇑";
+var DoubleUpDownArrow = "⇕";
+var DoubleVerticalBar = "∥";
+var DownArrowBar = "⤓";
+var downarrow = "↓";
+var DownArrow = "↓";
+var Downarrow = "⇓";
+var DownArrowUpArrow = "⇵";
+var DownBreve = "̑";
+var downdownarrows = "⇊";
+var downharpoonleft = "⇃";
+var downharpoonright = "⇂";
+var DownLeftRightVector = "⥐";
+var DownLeftTeeVector = "⥞";
+var DownLeftVectorBar = "⥖";
+var DownLeftVector = "↽";
+var DownRightTeeVector = "⥟";
+var DownRightVectorBar = "⥗";
+var DownRightVector = "⇁";
+var DownTeeArrow = "↧";
+var DownTee = "⊤";
+var drbkarow = "⤐";
+var drcorn = "⌟";
+var drcrop = "⌌";
+var Dscr = "𝒟";
+var dscr = "𝒹";
+var DScy = "Ѕ";
+var dscy = "ѕ";
+var dsol = "⧶";
+var Dstrok = "Đ";
+var dstrok = "đ";
+var dtdot = "⋱";
+var dtri = "▿";
+var dtrif = "▾";
+var duarr = "⇵";
+var duhar = "⥯";
+var dwangle = "⦦";
+var DZcy = "Џ";
+var dzcy = "џ";
+var dzigrarr = "⟿";
+var Eacute$1 = "É";
+var eacute$1 = "é";
+var easter = "⩮";
+var Ecaron = "Ě";
+var ecaron = "ě";
+var Ecirc$1 = "Ê";
+var ecirc$1 = "ê";
+var ecir = "≖";
+var ecolon = "≕";
+var Ecy = "Э";
+var ecy = "э";
+var eDDot = "⩷";
+var Edot = "Ė";
+var edot = "ė";
+var eDot = "≑";
+var ee = "ⅇ";
+var efDot = "≒";
+var Efr = "𝔈";
+var efr = "𝔢";
+var eg = "⪚";
+var Egrave$1 = "È";
+var egrave$1 = "è";
+var egs = "⪖";
+var egsdot = "⪘";
+var el = "⪙";
+var esm_Element = "∈";
+var elinters = "⏧";
+var ell = "ℓ";
+var els = "⪕";
+var elsdot = "⪗";
+var Emacr = "Ē";
+var emacr = "ē";
+var esm_empty = "∅";
+var emptyset = "∅";
+var EmptySmallSquare = "◻";
+var emptyv = "∅";
+var EmptyVerySmallSquare = "▫";
+var emsp13 = " ";
+var emsp14 = " ";
+var emsp = " ";
+var ENG = "Ŋ";
+var eng = "ŋ";
+var ensp = " ";
+var Eogon = "Ę";
+var eogon = "ę";
+var Eopf = "𝔼";
+var eopf = "𝕖";
+var epar = "⋕";
+var eparsl = "⧣";
+var eplus = "⩱";
+var epsi = "ε";
+var Epsilon = "Ε";
+var epsilon = "ε";
+var epsiv = "ϵ";
+var eqcirc = "≖";
+var eqcolon = "≕";
+var eqsim = "≂";
+var eqslantgtr = "⪖";
+var eqslantless = "⪕";
+var Equal = "⩵";
+var equals = "=";
+var EqualTilde = "≂";
+var equest = "≟";
+var Equilibrium = "⇌";
+var equiv = "≡";
+var equivDD = "⩸";
+var eqvparsl = "⧥";
+var erarr = "⥱";
+var erDot = "≓";
+var escr = "ℯ";
+var Escr = "ℰ";
+var esdot = "≐";
+var Esim = "⩳";
+var esim = "≂";
+var Eta = "Η";
+var eta = "η";
+var ETH$1 = "Ð";
+var eth$1 = "ð";
+var Euml$1 = "Ë";
+var euml$1 = "ë";
+var euro = "€";
+var excl = "!";
+var exist = "∃";
+var Exists = "∃";
+var expectation = "ℰ";
+var exponentiale = "ⅇ";
+var ExponentialE = "ⅇ";
+var fallingdotseq = "≒";
+var Fcy = "Ф";
+var fcy = "ф";
+var female = "♀";
+var ffilig = "ffi";
+var fflig = "ff";
+var ffllig = "ffl";
+var Ffr = "𝔉";
+var ffr = "𝔣";
+var filig = "fi";
+var FilledSmallSquare = "◼";
+var FilledVerySmallSquare = "▪";
+var fjlig = "fj";
+var flat = "♭";
+var fllig = "fl";
+var fltns = "▱";
+var fnof = "ƒ";
+var Fopf = "𝔽";
+var fopf = "𝕗";
+var forall = "∀";
+var ForAll = "∀";
+var fork = "⋔";
+var forkv = "⫙";
+var Fouriertrf = "ℱ";
+var fpartint = "⨍";
+var frac12$1 = "½";
+var frac13 = "⅓";
+var frac14$1 = "¼";
+var frac15 = "⅕";
+var frac16 = "⅙";
+var frac18 = "⅛";
+var frac23 = "⅔";
+var frac25 = "⅖";
+var frac34$1 = "¾";
+var frac35 = "⅗";
+var frac38 = "⅜";
+var frac45 = "⅘";
+var frac56 = "⅚";
+var frac58 = "⅝";
+var frac78 = "⅞";
+var frasl = "⁄";
+var frown = "⌢";
+var fscr = "𝒻";
+var Fscr = "ℱ";
+var gacute = "ǵ";
+var Gamma = "Γ";
+var gamma = "γ";
+var Gammad = "Ϝ";
+var gammad = "ϝ";
+var gap = "⪆";
+var Gbreve = "Ğ";
+var gbreve = "ğ";
+var Gcedil = "Ģ";
+var Gcirc = "Ĝ";
+var gcirc = "ĝ";
+var Gcy = "Г";
+var gcy = "г";
+var Gdot = "Ġ";
+var gdot = "ġ";
+var ge = "≥";
+var gE = "≧";
+var gEl = "⪌";
+var gel = "⋛";
+var geq = "≥";
+var geqq = "≧";
+var geqslant = "⩾";
+var gescc = "⪩";
+var ges = "⩾";
+var gesdot = "⪀";
+var gesdoto = "⪂";
+var gesdotol = "⪄";
+var gesl = "⋛︀";
+var gesles = "⪔";
+var Gfr = "𝔊";
+var gfr = "𝔤";
+var gg = "≫";
+var Gg = "⋙";
+var ggg = "⋙";
+var gimel = "ℷ";
+var GJcy = "Ѓ";
+var gjcy = "ѓ";
+var gla = "⪥";
+var gl = "≷";
+var glE = "⪒";
+var glj = "⪤";
+var gnap = "⪊";
+var gnapprox = "⪊";
+var gne = "⪈";
+var gnE = "≩";
+var gneq = "⪈";
+var gneqq = "≩";
+var gnsim = "⋧";
+var Gopf = "𝔾";
+var gopf = "𝕘";
+var grave = "`";
+var GreaterEqual = "≥";
+var GreaterEqualLess = "⋛";
+var GreaterFullEqual = "≧";
+var GreaterGreater = "⪢";
+var GreaterLess = "≷";
+var GreaterSlantEqual = "⩾";
+var GreaterTilde = "≳";
+var Gscr = "𝒢";
+var gscr = "ℊ";
+var gsim = "≳";
+var gsime = "⪎";
+var gsiml = "⪐";
+var gtcc = "⪧";
+var gtcir = "⩺";
+var gt$2 = ">";
+var GT$1 = ">";
+var Gt = "≫";
+var gtdot = "⋗";
+var gtlPar = "⦕";
+var gtquest = "⩼";
+var gtrapprox = "⪆";
+var gtrarr = "⥸";
+var gtrdot = "⋗";
+var gtreqless = "⋛";
+var gtreqqless = "⪌";
+var gtrless = "≷";
+var gtrsim = "≳";
+var gvertneqq = "≩︀";
+var gvnE = "≩︀";
+var Hacek = "ˇ";
+var hairsp = " ";
+var half = "½";
+var hamilt = "ℋ";
+var HARDcy = "Ъ";
+var hardcy = "ъ";
+var harrcir = "⥈";
+var harr = "↔";
+var hArr = "⇔";
+var harrw = "↭";
+var Hat = "^";
+var hbar = "ℏ";
+var Hcirc = "Ĥ";
+var hcirc = "ĥ";
+var hearts = "♥";
+var heartsuit = "♥";
+var hellip = "…";
+var hercon = "⊹";
+var hfr = "𝔥";
+var Hfr = "ℌ";
+var HilbertSpace = "ℋ";
+var hksearow = "⤥";
+var hkswarow = "⤦";
+var hoarr = "⇿";
+var homtht = "∻";
+var hookleftarrow = "↩";
+var hookrightarrow = "↪";
+var hopf = "𝕙";
+var Hopf = "ℍ";
+var horbar = "―";
+var HorizontalLine = "─";
+var hscr = "𝒽";
+var Hscr = "ℋ";
+var hslash = "ℏ";
+var Hstrok = "Ħ";
+var hstrok = "ħ";
+var HumpDownHump = "≎";
+var HumpEqual = "≏";
+var hybull = "⁃";
+var hyphen = "‐";
+var Iacute$1 = "Í";
+var iacute$1 = "í";
+var ic = "";
+var Icirc$1 = "Î";
+var icirc$1 = "î";
+var Icy = "И";
+var icy = "и";
+var Idot = "İ";
+var IEcy = "Е";
+var iecy = "е";
+var iexcl$1 = "¡";
+var iff = "⇔";
+var ifr = "𝔦";
+var Ifr = "ℑ";
+var Igrave$1 = "Ì";
+var igrave$1 = "ì";
+var ii = "ⅈ";
+var iiiint = "⨌";
+var iiint = "∭";
+var iinfin = "⧜";
+var iiota = "℩";
+var IJlig = "IJ";
+var ijlig = "ij";
+var Imacr = "Ī";
+var imacr = "ī";
+var esm_image = "ℑ";
+var ImaginaryI = "ⅈ";
+var imagline = "ℐ";
+var imagpart = "ℑ";
+var imath = "ı";
+var Im = "ℑ";
+var imof = "⊷";
+var imped = "Ƶ";
+var Implies = "⇒";
+var incare = "℅";
+var infin = "∞";
+var infintie = "⧝";
+var inodot = "ı";
+var intcal = "⊺";
+var esm_int = "∫";
+var Int = "∬";
+var integers = "ℤ";
+var Integral = "∫";
+var intercal = "⊺";
+var Intersection = "⋂";
+var intlarhk = "⨗";
+var intprod = "⨼";
+var InvisibleComma = "";
+var InvisibleTimes = "";
+var IOcy = "Ё";
+var iocy = "ё";
+var Iogon = "Į";
+var iogon = "į";
+var Iopf = "𝕀";
+var iopf = "𝕚";
+var Iota = "Ι";
+var iota = "ι";
+var iprod = "⨼";
+var iquest$1 = "¿";
+var iscr = "𝒾";
+var Iscr = "ℐ";
+var isin = "∈";
+var isindot = "⋵";
+var isinE = "⋹";
+var isins = "⋴";
+var isinsv = "⋳";
+var isinv = "∈";
+var it = "";
+var Itilde = "Ĩ";
+var itilde = "ĩ";
+var Iukcy = "І";
+var iukcy = "і";
+var Iuml$1 = "Ï";
+var iuml$1 = "ï";
+var Jcirc = "Ĵ";
+var jcirc = "ĵ";
+var Jcy = "Й";
+var jcy = "й";
+var Jfr = "𝔍";
+var jfr = "𝔧";
+var jmath = "ȷ";
+var Jopf = "𝕁";
+var jopf = "𝕛";
+var Jscr = "𝒥";
+var jscr = "𝒿";
+var Jsercy = "Ј";
+var jsercy = "ј";
+var Jukcy = "Є";
+var jukcy = "є";
+var Kappa = "Κ";
+var kappa = "κ";
+var kappav = "ϰ";
+var Kcedil = "Ķ";
+var kcedil = "ķ";
+var Kcy = "К";
+var kcy = "к";
+var Kfr = "𝔎";
+var kfr = "𝔨";
+var kgreen = "ĸ";
+var KHcy = "Х";
+var khcy = "х";
+var KJcy = "Ќ";
+var kjcy = "ќ";
+var Kopf = "𝕂";
+var kopf = "𝕜";
+var Kscr = "𝒦";
+var kscr = "𝓀";
+var lAarr = "⇚";
+var Lacute = "Ĺ";
+var lacute = "ĺ";
+var laemptyv = "⦴";
+var lagran = "ℒ";
+var Lambda = "Λ";
+var lambda = "λ";
+var lang = "⟨";
+var Lang = "⟪";
+var langd = "⦑";
+var langle = "⟨";
+var lap = "⪅";
+var Laplacetrf = "ℒ";
+var laquo$1 = "«";
+var larrb = "⇤";
+var larrbfs = "⤟";
+var larr = "←";
+var Larr = "↞";
+var lArr = "⇐";
+var larrfs = "⤝";
+var larrhk = "↩";
+var larrlp = "↫";
+var larrpl = "⤹";
+var larrsim = "⥳";
+var larrtl = "↢";
+var latail = "⤙";
+var lAtail = "⤛";
+var lat = "⪫";
+var late = "⪭";
+var lates = "⪭︀";
+var lbarr = "⤌";
+var lBarr = "⤎";
+var lbbrk = "❲";
+var lbrace = "{";
+var lbrack = "[";
+var lbrke = "⦋";
+var lbrksld = "⦏";
+var lbrkslu = "⦍";
+var Lcaron = "Ľ";
+var lcaron = "ľ";
+var Lcedil = "Ļ";
+var lcedil = "ļ";
+var lceil = "⌈";
+var lcub = "{";
+var Lcy = "Л";
+var lcy = "л";
+var ldca = "⤶";
+var ldquo = "“";
+var ldquor = "„";
+var ldrdhar = "⥧";
+var ldrushar = "⥋";
+var ldsh = "↲";
+var le = "≤";
+var lE = "≦";
+var LeftAngleBracket = "⟨";
+var LeftArrowBar = "⇤";
+var leftarrow = "←";
+var LeftArrow = "←";
+var Leftarrow = "⇐";
+var LeftArrowRightArrow = "⇆";
+var leftarrowtail = "↢";
+var LeftCeiling = "⌈";
+var LeftDoubleBracket = "⟦";
+var LeftDownTeeVector = "⥡";
+var LeftDownVectorBar = "⥙";
+var LeftDownVector = "⇃";
+var LeftFloor = "⌊";
+var leftharpoondown = "↽";
+var leftharpoonup = "↼";
+var leftleftarrows = "⇇";
+var leftrightarrow = "↔";
+var LeftRightArrow = "↔";
+var Leftrightarrow = "⇔";
+var leftrightarrows = "⇆";
+var leftrightharpoons = "⇋";
+var leftrightsquigarrow = "↭";
+var LeftRightVector = "⥎";
+var LeftTeeArrow = "↤";
+var LeftTee = "⊣";
+var LeftTeeVector = "⥚";
+var leftthreetimes = "⋋";
+var LeftTriangleBar = "⧏";
+var LeftTriangle = "⊲";
+var LeftTriangleEqual = "⊴";
+var LeftUpDownVector = "⥑";
+var LeftUpTeeVector = "⥠";
+var LeftUpVectorBar = "⥘";
+var LeftUpVector = "↿";
+var LeftVectorBar = "⥒";
+var LeftVector = "↼";
+var lEg = "⪋";
+var leg = "⋚";
+var leq = "≤";
+var leqq = "≦";
+var leqslant = "⩽";
+var lescc = "⪨";
+var les = "⩽";
+var lesdot = "⩿";
+var lesdoto = "⪁";
+var lesdotor = "⪃";
+var lesg = "⋚︀";
+var lesges = "⪓";
+var lessapprox = "⪅";
+var lessdot = "⋖";
+var lesseqgtr = "⋚";
+var lesseqqgtr = "⪋";
+var LessEqualGreater = "⋚";
+var LessFullEqual = "≦";
+var LessGreater = "≶";
+var lessgtr = "≶";
+var LessLess = "⪡";
+var lesssim = "≲";
+var LessSlantEqual = "⩽";
+var LessTilde = "≲";
+var lfisht = "⥼";
+var lfloor = "⌊";
+var Lfr = "𝔏";
+var lfr = "𝔩";
+var lg = "≶";
+var lgE = "⪑";
+var lHar = "⥢";
+var lhard = "↽";
+var lharu = "↼";
+var lharul = "⥪";
+var lhblk = "▄";
+var LJcy = "Љ";
+var ljcy = "љ";
+var llarr = "⇇";
+var ll = "≪";
+var Ll = "⋘";
+var llcorner = "⌞";
+var Lleftarrow = "⇚";
+var llhard = "⥫";
+var lltri = "◺";
+var Lmidot = "Ŀ";
+var lmidot = "ŀ";
+var lmoustache = "⎰";
+var lmoust = "⎰";
+var lnap = "⪉";
+var lnapprox = "⪉";
+var lne = "⪇";
+var lnE = "≨";
+var lneq = "⪇";
+var lneqq = "≨";
+var lnsim = "⋦";
+var loang = "⟬";
+var loarr = "⇽";
+var lobrk = "⟦";
+var longleftarrow = "⟵";
+var LongLeftArrow = "⟵";
+var Longleftarrow = "⟸";
+var longleftrightarrow = "⟷";
+var LongLeftRightArrow = "⟷";
+var Longleftrightarrow = "⟺";
+var longmapsto = "⟼";
+var longrightarrow = "⟶";
+var LongRightArrow = "⟶";
+var Longrightarrow = "⟹";
+var looparrowleft = "↫";
+var looparrowright = "↬";
+var lopar = "⦅";
+var Lopf = "𝕃";
+var lopf = "𝕝";
+var loplus = "⨭";
+var lotimes = "⨴";
+var lowast = "∗";
+var lowbar = "_";
+var LowerLeftArrow = "↙";
+var LowerRightArrow = "↘";
+var loz = "◊";
+var lozenge = "◊";
+var lozf = "⧫";
+var lpar = "(";
+var lparlt = "⦓";
+var lrarr = "⇆";
+var lrcorner = "⌟";
+var lrhar = "⇋";
+var lrhard = "⥭";
+var lrm = "";
+var lrtri = "⊿";
+var lsaquo = "‹";
+var lscr = "𝓁";
+var Lscr = "ℒ";
+var lsh = "↰";
+var Lsh = "↰";
+var lsim = "≲";
+var lsime = "⪍";
+var lsimg = "⪏";
+var lsqb = "[";
+var lsquo = "‘";
+var lsquor = "‚";
+var Lstrok = "Ł";
+var lstrok = "ł";
+var ltcc = "⪦";
+var ltcir = "⩹";
+var lt$2 = "<";
+var LT$1 = "<";
+var Lt = "≪";
+var ltdot = "⋖";
+var lthree = "⋋";
+var ltimes = "⋉";
+var ltlarr = "⥶";
+var ltquest = "⩻";
+var ltri = "◃";
+var ltrie = "⊴";
+var ltrif = "◂";
+var ltrPar = "⦖";
+var lurdshar = "⥊";
+var luruhar = "⥦";
+var lvertneqq = "≨︀";
+var lvnE = "≨︀";
+var macr$1 = "¯";
+var male = "♂";
+var malt = "✠";
+var maltese = "✠";
+var map = "↦";
+var mapsto = "↦";
+var mapstodown = "↧";
+var mapstoleft = "↤";
+var mapstoup = "↥";
+var marker = "▮";
+var mcomma = "⨩";
+var Mcy = "М";
+var mcy = "м";
+var mdash = "—";
+var mDDot = "∺";
+var measuredangle = "∡";
+var MediumSpace = " ";
+var Mellintrf = "ℳ";
+var Mfr = "𝔐";
+var mfr = "𝔪";
+var mho = "℧";
+var micro$1 = "µ";
+var midast = "*";
+var midcir = "⫰";
+var mid = "∣";
+var middot$1 = "·";
+var minusb = "⊟";
+var minus = "−";
+var minusd = "∸";
+var minusdu = "⨪";
+var MinusPlus = "∓";
+var mlcp = "⫛";
+var mldr = "…";
+var mnplus = "∓";
+var models = "⊧";
+var Mopf = "𝕄";
+var mopf = "𝕞";
+var mp = "∓";
+var mscr = "𝓂";
+var Mscr = "ℳ";
+var mstpos = "∾";
+var Mu = "Μ";
+var mu = "μ";
+var multimap = "⊸";
+var mumap = "⊸";
+var nabla = "∇";
+var Nacute = "Ń";
+var nacute = "ń";
+var nang = "∠⃒";
+var nap = "≉";
+var napE = "⩰̸";
+var napid = "≋̸";
+var napos = "ʼn";
+var napprox = "≉";
+var natural = "♮";
+var naturals = "ℕ";
+var natur = "♮";
+var nbsp$1 = " ";
+var nbump = "≎̸";
+var nbumpe = "≏̸";
+var ncap = "⩃";
+var Ncaron = "Ň";
+var ncaron = "ň";
+var Ncedil = "Ņ";
+var ncedil = "ņ";
+var ncong = "≇";
+var ncongdot = "⩭̸";
+var ncup = "⩂";
+var Ncy = "Н";
+var ncy = "н";
+var ndash = "–";
+var nearhk = "⤤";
+var nearr = "↗";
+var neArr = "⇗";
+var nearrow = "↗";
+var ne = "≠";
+var nedot = "≐̸";
+var NegativeMediumSpace = "";
+var NegativeThickSpace = "";
+var NegativeThinSpace = "";
+var NegativeVeryThinSpace = "";
+var nequiv = "≢";
+var nesear = "⤨";
+var nesim = "≂̸";
+var NestedGreaterGreater = "≫";
+var NestedLessLess = "≪";
+var NewLine = "\n";
+var nexist = "∄";
+var nexists = "∄";
+var Nfr = "𝔑";
+var nfr = "𝔫";
+var ngE = "≧̸";
+var nge = "≱";
+var ngeq = "≱";
+var ngeqq = "≧̸";
+var ngeqslant = "⩾̸";
+var nges = "⩾̸";
+var nGg = "⋙̸";
+var ngsim = "≵";
+var nGt = "≫⃒";
+var ngt = "≯";
+var ngtr = "≯";
+var nGtv = "≫̸";
+var nharr = "↮";
+var nhArr = "⇎";
+var nhpar = "⫲";
+var ni = "∋";
+var nis = "⋼";
+var nisd = "⋺";
+var niv = "∋";
+var NJcy = "Њ";
+var njcy = "њ";
+var nlarr = "↚";
+var nlArr = "⇍";
+var nldr = "‥";
+var nlE = "≦̸";
+var nle = "≰";
+var nleftarrow = "↚";
+var nLeftarrow = "⇍";
+var nleftrightarrow = "↮";
+var nLeftrightarrow = "⇎";
+var nleq = "≰";
+var nleqq = "≦̸";
+var nleqslant = "⩽̸";
+var nles = "⩽̸";
+var nless = "≮";
+var nLl = "⋘̸";
+var nlsim = "≴";
+var nLt = "≪⃒";
+var nlt = "≮";
+var nltri = "⋪";
+var nltrie = "⋬";
+var nLtv = "≪̸";
+var nmid = "∤";
+var NoBreak = "";
+var NonBreakingSpace = " ";
+var nopf = "𝕟";
+var Nopf = "ℕ";
+var Not = "⫬";
+var not$1 = "¬";
+var NotCongruent = "≢";
+var NotCupCap = "≭";
+var NotDoubleVerticalBar = "∦";
+var NotElement = "∉";
+var NotEqual = "≠";
+var NotEqualTilde = "≂̸";
+var NotExists = "∄";
+var NotGreater = "≯";
+var NotGreaterEqual = "≱";
+var NotGreaterFullEqual = "≧̸";
+var NotGreaterGreater = "≫̸";
+var NotGreaterLess = "≹";
+var NotGreaterSlantEqual = "⩾̸";
+var NotGreaterTilde = "≵";
+var NotHumpDownHump = "≎̸";
+var NotHumpEqual = "≏̸";
+var notin = "∉";
+var notindot = "⋵̸";
+var notinE = "⋹̸";
+var notinva = "∉";
+var notinvb = "⋷";
+var notinvc = "⋶";
+var NotLeftTriangleBar = "⧏̸";
+var NotLeftTriangle = "⋪";
+var NotLeftTriangleEqual = "⋬";
+var NotLess = "≮";
+var NotLessEqual = "≰";
+var NotLessGreater = "≸";
+var NotLessLess = "≪̸";
+var NotLessSlantEqual = "⩽̸";
+var NotLessTilde = "≴";
+var NotNestedGreaterGreater = "⪢̸";
+var NotNestedLessLess = "⪡̸";
+var notni = "∌";
+var notniva = "∌";
+var notnivb = "⋾";
+var notnivc = "⋽";
+var NotPrecedes = "⊀";
+var NotPrecedesEqual = "⪯̸";
+var NotPrecedesSlantEqual = "⋠";
+var NotReverseElement = "∌";
+var NotRightTriangleBar = "⧐̸";
+var NotRightTriangle = "⋫";
+var NotRightTriangleEqual = "⋭";
+var NotSquareSubset = "⊏̸";
+var NotSquareSubsetEqual = "⋢";
+var NotSquareSuperset = "⊐̸";
+var NotSquareSupersetEqual = "⋣";
+var NotSubset = "⊂⃒";
+var NotSubsetEqual = "⊈";
+var NotSucceeds = "⊁";
+var NotSucceedsEqual = "⪰̸";
+var NotSucceedsSlantEqual = "⋡";
+var NotSucceedsTilde = "≿̸";
+var NotSuperset = "⊃⃒";
+var NotSupersetEqual = "⊉";
+var NotTilde = "≁";
+var NotTildeEqual = "≄";
+var NotTildeFullEqual = "≇";
+var NotTildeTilde = "≉";
+var NotVerticalBar = "∤";
+var nparallel = "∦";
+var npar = "∦";
+var nparsl = "⫽⃥";
+var npart = "∂̸";
+var npolint = "⨔";
+var npr = "⊀";
+var nprcue = "⋠";
+var nprec = "⊀";
+var npreceq = "⪯̸";
+var npre = "⪯̸";
+var nrarrc = "⤳̸";
+var nrarr = "↛";
+var nrArr = "⇏";
+var nrarrw = "↝̸";
+var nrightarrow = "↛";
+var nRightarrow = "⇏";
+var nrtri = "⋫";
+var nrtrie = "⋭";
+var nsc = "⊁";
+var nsccue = "⋡";
+var nsce = "⪰̸";
+var Nscr = "𝒩";
+var nscr = "𝓃";
+var nshortmid = "∤";
+var nshortparallel = "∦";
+var nsim = "≁";
+var nsime = "≄";
+var nsimeq = "≄";
+var nsmid = "∤";
+var nspar = "∦";
+var nsqsube = "⋢";
+var nsqsupe = "⋣";
+var nsub = "⊄";
+var nsubE = "⫅̸";
+var nsube = "⊈";
+var nsubset = "⊂⃒";
+var nsubseteq = "⊈";
+var nsubseteqq = "⫅̸";
+var nsucc = "⊁";
+var nsucceq = "⪰̸";
+var nsup = "⊅";
+var nsupE = "⫆̸";
+var nsupe = "⊉";
+var nsupset = "⊃⃒";
+var nsupseteq = "⊉";
+var nsupseteqq = "⫆̸";
+var ntgl = "≹";
+var Ntilde$1 = "Ñ";
+var ntilde$1 = "ñ";
+var ntlg = "≸";
+var ntriangleleft = "⋪";
+var ntrianglelefteq = "⋬";
+var ntriangleright = "⋫";
+var ntrianglerighteq = "⋭";
+var Nu = "Ν";
+var nu = "ν";
+var num = "#";
+var numero = "№";
+var numsp = " ";
+var nvap = "≍⃒";
+var nvdash = "⊬";
+var nvDash = "⊭";
+var nVdash = "⊮";
+var nVDash = "⊯";
+var nvge = "≥⃒";
+var nvgt = ">⃒";
+var nvHarr = "⤄";
+var nvinfin = "⧞";
+var nvlArr = "⤂";
+var nvle = "≤⃒";
+var nvlt = "<⃒";
+var nvltrie = "⊴⃒";
+var nvrArr = "⤃";
+var nvrtrie = "⊵⃒";
+var nvsim = "∼⃒";
+var nwarhk = "⤣";
+var nwarr = "↖";
+var nwArr = "⇖";
+var nwarrow = "↖";
+var nwnear = "⤧";
+var Oacute$1 = "Ó";
+var oacute$1 = "ó";
+var oast = "⊛";
+var Ocirc$1 = "Ô";
+var ocirc$1 = "ô";
+var ocir = "⊚";
+var Ocy = "О";
+var ocy = "о";
+var odash = "⊝";
+var Odblac = "Ő";
+var odblac = "ő";
+var odiv = "⨸";
+var odot = "⊙";
+var odsold = "⦼";
+var OElig = "Œ";
+var oelig = "œ";
+var ofcir = "⦿";
+var Ofr = "𝔒";
+var ofr = "𝔬";
+var ogon = "˛";
+var Ograve$1 = "Ò";
+var ograve$1 = "ò";
+var ogt = "⧁";
+var ohbar = "⦵";
+var ohm = "Ω";
+var oint = "∮";
+var olarr = "↺";
+var olcir = "⦾";
+var olcross = "⦻";
+var oline = "‾";
+var olt = "⧀";
+var Omacr = "Ō";
+var omacr = "ō";
+var Omega = "Ω";
+var omega = "ω";
+var Omicron = "Ο";
+var omicron = "ο";
+var omid = "⦶";
+var ominus = "⊖";
+var Oopf = "𝕆";
+var oopf = "𝕠";
+var opar = "⦷";
+var OpenCurlyDoubleQuote = "“";
+var OpenCurlyQuote = "‘";
+var operp = "⦹";
+var oplus = "⊕";
+var orarr = "↻";
+var Or = "⩔";
+var or = "∨";
+var ord = "⩝";
+var order = "ℴ";
+var orderof = "ℴ";
+var ordf$1 = "ª";
+var ordm$1 = "º";
+var origof = "⊶";
+var oror = "⩖";
+var orslope = "⩗";
+var orv = "⩛";
+var oS = "Ⓢ";
+var Oscr = "𝒪";
+var oscr = "ℴ";
+var Oslash$1 = "Ø";
+var oslash$1 = "ø";
+var osol = "⊘";
+var Otilde$1 = "Õ";
+var otilde$1 = "õ";
+var otimesas = "⨶";
+var Otimes = "⨷";
+var otimes = "⊗";
+var Ouml$1 = "Ö";
+var ouml$1 = "ö";
+var ovbar = "⌽";
+var OverBar = "‾";
+var OverBrace = "⏞";
+var OverBracket = "⎴";
+var OverParenthesis = "⏜";
+var para$1 = "¶";
+var parallel = "∥";
+var par = "∥";
+var parsim = "⫳";
+var parsl = "⫽";
+var part = "∂";
+var PartialD = "∂";
+var Pcy = "П";
+var pcy = "п";
+var percnt = "%";
+var period = ".";
+var permil = "‰";
+var perp = "⊥";
+var pertenk = "‱";
+var Pfr = "𝔓";
+var pfr = "𝔭";
+var Phi = "Φ";
+var phi = "φ";
+var phiv = "ϕ";
+var phmmat = "ℳ";
+var phone = "☎";
+var Pi = "Π";
+var pi = "π";
+var pitchfork = "⋔";
+var piv = "ϖ";
+var planck = "ℏ";
+var planckh = "ℎ";
+var plankv = "ℏ";
+var plusacir = "⨣";
+var plusb = "⊞";
+var pluscir = "⨢";
+var plus = "+";
+var plusdo = "∔";
+var plusdu = "⨥";
+var pluse = "⩲";
+var PlusMinus = "±";
+var plusmn$1 = "±";
+var plussim = "⨦";
+var plustwo = "⨧";
+var pm = "±";
+var Poincareplane = "ℌ";
+var pointint = "⨕";
+var popf = "𝕡";
+var Popf = "ℙ";
+var pound$1 = "£";
+var prap = "⪷";
+var Pr = "⪻";
+var pr = "≺";
+var prcue = "≼";
+var precapprox = "⪷";
+var prec = "≺";
+var preccurlyeq = "≼";
+var Precedes = "≺";
+var PrecedesEqual = "⪯";
+var PrecedesSlantEqual = "≼";
+var PrecedesTilde = "≾";
+var preceq = "⪯";
+var precnapprox = "⪹";
+var precneqq = "⪵";
+var precnsim = "⋨";
+var pre = "⪯";
+var prE = "⪳";
+var precsim = "≾";
+var prime = "′";
+var Prime = "″";
+var primes = "ℙ";
+var prnap = "⪹";
+var prnE = "⪵";
+var prnsim = "⋨";
+var prod = "∏";
+var Product = "∏";
+var profalar = "⌮";
+var profline = "⌒";
+var profsurf = "⌓";
+var prop = "∝";
+var Proportional = "∝";
+var Proportion = "∷";
+var propto = "∝";
+var prsim = "≾";
+var prurel = "⊰";
+var Pscr = "𝒫";
+var pscr = "𝓅";
+var Psi = "Ψ";
+var psi = "ψ";
+var puncsp = " ";
+var Qfr = "𝔔";
+var qfr = "𝔮";
+var qint = "⨌";
+var qopf = "𝕢";
+var Qopf = "ℚ";
+var qprime = "⁗";
+var Qscr = "𝒬";
+var qscr = "𝓆";
+var quaternions = "ℍ";
+var quatint = "⨖";
+var quest = "?";
+var questeq = "≟";
+var quot$2 = "\"";
+var QUOT$1 = "\"";
+var rAarr = "⇛";
+var race = "∽̱";
+var Racute = "Ŕ";
+var racute = "ŕ";
+var radic = "√";
+var raemptyv = "⦳";
+var rang = "⟩";
+var Rang = "⟫";
+var rangd = "⦒";
+var range = "⦥";
+var rangle = "⟩";
+var raquo$1 = "»";
+var rarrap = "⥵";
+var rarrb = "⇥";
+var rarrbfs = "⤠";
+var rarrc = "⤳";
+var rarr = "→";
+var Rarr = "↠";
+var rArr = "⇒";
+var rarrfs = "⤞";
+var rarrhk = "↪";
+var rarrlp = "↬";
+var rarrpl = "⥅";
+var rarrsim = "⥴";
+var Rarrtl = "⤖";
+var rarrtl = "↣";
+var rarrw = "↝";
+var ratail = "⤚";
+var rAtail = "⤜";
+var ratio = "∶";
+var rationals = "ℚ";
+var rbarr = "⤍";
+var rBarr = "⤏";
+var RBarr = "⤐";
+var rbbrk = "❳";
+var rbrace = "}";
+var rbrack = "]";
+var rbrke = "⦌";
+var rbrksld = "⦎";
+var rbrkslu = "⦐";
+var Rcaron = "Ř";
+var rcaron = "ř";
+var Rcedil = "Ŗ";
+var rcedil = "ŗ";
+var rceil = "⌉";
+var rcub = "}";
+var Rcy = "Р";
+var rcy = "р";
+var rdca = "⤷";
+var rdldhar = "⥩";
+var rdquo = "”";
+var rdquor = "”";
+var rdsh = "↳";
+var real = "ℜ";
+var realine = "ℛ";
+var realpart = "ℜ";
+var reals = "ℝ";
+var Re = "ℜ";
+var rect = "▭";
+var reg$1 = "®";
+var REG$1 = "®";
+var ReverseElement = "∋";
+var ReverseEquilibrium = "⇋";
+var ReverseUpEquilibrium = "⥯";
+var rfisht = "⥽";
+var rfloor = "⌋";
+var rfr = "𝔯";
+var Rfr = "ℜ";
+var rHar = "⥤";
+var rhard = "⇁";
+var rharu = "⇀";
+var rharul = "⥬";
+var Rho = "Ρ";
+var rho = "ρ";
+var rhov = "ϱ";
+var RightAngleBracket = "⟩";
+var RightArrowBar = "⇥";
+var rightarrow = "→";
+var RightArrow = "→";
+var Rightarrow = "⇒";
+var RightArrowLeftArrow = "⇄";
+var rightarrowtail = "↣";
+var RightCeiling = "⌉";
+var RightDoubleBracket = "⟧";
+var RightDownTeeVector = "⥝";
+var RightDownVectorBar = "⥕";
+var RightDownVector = "⇂";
+var RightFloor = "⌋";
+var rightharpoondown = "⇁";
+var rightharpoonup = "⇀";
+var rightleftarrows = "⇄";
+var rightleftharpoons = "⇌";
+var rightrightarrows = "⇉";
+var rightsquigarrow = "↝";
+var RightTeeArrow = "↦";
+var RightTee = "⊢";
+var RightTeeVector = "⥛";
+var rightthreetimes = "⋌";
+var RightTriangleBar = "⧐";
+var RightTriangle = "⊳";
+var RightTriangleEqual = "⊵";
+var RightUpDownVector = "⥏";
+var RightUpTeeVector = "⥜";
+var RightUpVectorBar = "⥔";
+var RightUpVector = "↾";
+var RightVectorBar = "⥓";
+var RightVector = "⇀";
+var ring = "˚";
+var risingdotseq = "≓";
+var rlarr = "⇄";
+var rlhar = "⇌";
+var rlm = "";
+var rmoustache = "⎱";
+var rmoust = "⎱";
+var rnmid = "⫮";
+var roang = "⟭";
+var roarr = "⇾";
+var robrk = "⟧";
+var ropar = "⦆";
+var ropf = "𝕣";
+var Ropf = "ℝ";
+var roplus = "⨮";
+var rotimes = "⨵";
+var RoundImplies = "⥰";
+var rpar = ")";
+var rpargt = "⦔";
+var rppolint = "⨒";
+var rrarr = "⇉";
+var Rrightarrow = "⇛";
+var rsaquo = "›";
+var rscr = "𝓇";
+var Rscr = "ℛ";
+var rsh = "↱";
+var Rsh = "↱";
+var rsqb = "]";
+var rsquo = "’";
+var rsquor = "’";
+var rthree = "⋌";
+var rtimes = "⋊";
+var rtri = "▹";
+var rtrie = "⊵";
+var rtrif = "▸";
+var rtriltri = "⧎";
+var RuleDelayed = "⧴";
+var ruluhar = "⥨";
+var rx = "℞";
+var Sacute = "Ś";
+var sacute = "ś";
+var sbquo = "‚";
+var scap = "⪸";
+var Scaron = "Š";
+var scaron = "š";
+var Sc = "⪼";
+var sc = "≻";
+var sccue = "≽";
+var sce = "⪰";
+var scE = "⪴";
+var Scedil = "Ş";
+var scedil = "ş";
+var Scirc = "Ŝ";
+var scirc = "ŝ";
+var scnap = "⪺";
+var scnE = "⪶";
+var scnsim = "⋩";
+var scpolint = "⨓";
+var scsim = "≿";
+var Scy = "С";
+var scy = "с";
+var sdotb = "⊡";
+var sdot = "⋅";
+var sdote = "⩦";
+var searhk = "⤥";
+var searr = "↘";
+var seArr = "⇘";
+var searrow = "↘";
+var sect$1 = "§";
+var semi = ";";
+var seswar = "⤩";
+var setminus = "∖";
+var setmn = "∖";
+var sext = "✶";
+var Sfr = "𝔖";
+var sfr = "𝔰";
+var sfrown = "⌢";
+var sharp = "♯";
+var SHCHcy = "Щ";
+var shchcy = "щ";
+var SHcy = "Ш";
+var shcy = "ш";
+var ShortDownArrow = "↓";
+var ShortLeftArrow = "←";
+var shortmid = "∣";
+var shortparallel = "∥";
+var ShortRightArrow = "→";
+var ShortUpArrow = "↑";
+var shy$1 = "";
+var Sigma = "Σ";
+var sigma = "σ";
+var sigmaf = "ς";
+var sigmav = "ς";
+var sim = "∼";
+var simdot = "⩪";
+var sime = "≃";
+var simeq = "≃";
+var simg = "⪞";
+var simgE = "⪠";
+var siml = "⪝";
+var simlE = "⪟";
+var simne = "≆";
+var simplus = "⨤";
+var simrarr = "⥲";
+var slarr = "←";
+var SmallCircle = "∘";
+var smallsetminus = "∖";
+var smashp = "⨳";
+var smeparsl = "⧤";
+var smid = "∣";
+var smile = "⌣";
+var smt = "⪪";
+var smte = "⪬";
+var smtes = "⪬︀";
+var SOFTcy = "Ь";
+var softcy = "ь";
+var solbar = "⌿";
+var solb = "⧄";
+var sol = "/";
+var Sopf = "𝕊";
+var sopf = "𝕤";
+var spades = "♠";
+var spadesuit = "♠";
+var spar = "∥";
+var sqcap = "⊓";
+var sqcaps = "⊓︀";
+var sqcup = "⊔";
+var sqcups = "⊔︀";
+var Sqrt = "√";
+var sqsub = "⊏";
+var sqsube = "⊑";
+var sqsubset = "⊏";
+var sqsubseteq = "⊑";
+var sqsup = "⊐";
+var sqsupe = "⊒";
+var sqsupset = "⊐";
+var sqsupseteq = "⊒";
+var square = "□";
+var Square = "□";
+var SquareIntersection = "⊓";
+var SquareSubset = "⊏";
+var SquareSubsetEqual = "⊑";
+var SquareSuperset = "⊐";
+var SquareSupersetEqual = "⊒";
+var SquareUnion = "⊔";
+var squarf = "▪";
+var squ = "□";
+var squf = "▪";
+var srarr = "→";
+var Sscr = "𝒮";
+var sscr = "𝓈";
+var ssetmn = "∖";
+var ssmile = "⌣";
+var sstarf = "⋆";
+var Star = "⋆";
+var star = "☆";
+var starf = "★";
+var straightepsilon = "ϵ";
+var straightphi = "ϕ";
+var strns = "¯";
+var sub = "⊂";
+var Sub = "⋐";
+var subdot = "⪽";
+var subE = "⫅";
+var sube = "⊆";
+var subedot = "⫃";
+var submult = "⫁";
+var subnE = "⫋";
+var subne = "⊊";
+var subplus = "⪿";
+var subrarr = "⥹";
+var subset = "⊂";
+var Subset = "⋐";
+var subseteq = "⊆";
+var subseteqq = "⫅";
+var SubsetEqual = "⊆";
+var subsetneq = "⊊";
+var subsetneqq = "⫋";
+var subsim = "⫇";
+var subsub = "⫕";
+var subsup = "⫓";
+var succapprox = "⪸";
+var succ = "≻";
+var succcurlyeq = "≽";
+var Succeeds = "≻";
+var SucceedsEqual = "⪰";
+var SucceedsSlantEqual = "≽";
+var SucceedsTilde = "≿";
+var succeq = "⪰";
+var succnapprox = "⪺";
+var succneqq = "⪶";
+var succnsim = "⋩";
+var succsim = "≿";
+var SuchThat = "∋";
+var sum = "∑";
+var Sum = "∑";
+var sung = "♪";
+var sup1$1 = "¹";
+var sup2$1 = "²";
+var sup3$1 = "³";
+var sup = "⊃";
+var Sup = "⋑";
+var supdot = "⪾";
+var supdsub = "⫘";
+var supE = "⫆";
+var supe = "⊇";
+var supedot = "⫄";
+var Superset = "⊃";
+var SupersetEqual = "⊇";
+var suphsol = "⟉";
+var suphsub = "⫗";
+var suplarr = "⥻";
+var supmult = "⫂";
+var supnE = "⫌";
+var supne = "⊋";
+var supplus = "⫀";
+var supset = "⊃";
+var Supset = "⋑";
+var supseteq = "⊇";
+var supseteqq = "⫆";
+var supsetneq = "⊋";
+var supsetneqq = "⫌";
+var supsim = "⫈";
+var supsub = "⫔";
+var supsup = "⫖";
+var swarhk = "⤦";
+var swarr = "↙";
+var swArr = "⇙";
+var swarrow = "↙";
+var swnwar = "⤪";
+var szlig$1 = "ß";
+var Tab = "\t";
+var target = "⌖";
+var Tau = "Τ";
+var tau = "τ";
+var tbrk = "⎴";
+var Tcaron = "Ť";
+var tcaron = "ť";
+var Tcedil = "Ţ";
+var tcedil = "ţ";
+var Tcy = "Т";
+var tcy = "т";
+var tdot = "⃛";
+var telrec = "⌕";
+var Tfr = "𝔗";
+var tfr = "𝔱";
+var there4 = "∴";
+var therefore = "∴";
+var Therefore = "∴";
+var Theta = "Θ";
+var theta = "θ";
+var thetasym = "ϑ";
+var thetav = "ϑ";
+var thickapprox = "≈";
+var thicksim = "∼";
+var ThickSpace = " ";
+var ThinSpace = " ";
+var thinsp = " ";
+var thkap = "≈";
+var thksim = "∼";
+var THORN$1 = "Þ";
+var thorn$1 = "þ";
+var tilde = "˜";
+var Tilde = "∼";
+var TildeEqual = "≃";
+var TildeFullEqual = "≅";
+var TildeTilde = "≈";
+var timesbar = "⨱";
+var timesb = "⊠";
+var times$1 = "×";
+var timesd = "⨰";
+var tint = "∭";
+var toea = "⤨";
+var topbot = "⌶";
+var topcir = "⫱";
+var esm_top = "⊤";
+var Topf = "𝕋";
+var topf = "𝕥";
+var topfork = "⫚";
+var tosa = "⤩";
+var tprime = "‴";
+var trade = "™";
+var TRADE = "™";
+var triangle = "▵";
+var triangledown = "▿";
+var triangleleft = "◃";
+var trianglelefteq = "⊴";
+var triangleq = "≜";
+var triangleright = "▹";
+var trianglerighteq = "⊵";
+var tridot = "◬";
+var trie = "≜";
+var triminus = "⨺";
+var TripleDot = "⃛";
+var triplus = "⨹";
+var trisb = "⧍";
+var tritime = "⨻";
+var trpezium = "⏢";
+var Tscr = "𝒯";
+var tscr = "𝓉";
+var TScy = "Ц";
+var tscy = "ц";
+var TSHcy = "Ћ";
+var tshcy = "ћ";
+var Tstrok = "Ŧ";
+var tstrok = "ŧ";
+var twixt = "≬";
+var twoheadleftarrow = "↞";
+var twoheadrightarrow = "↠";
+var Uacute$1 = "Ú";
+var uacute$1 = "ú";
+var uarr = "↑";
+var Uarr = "↟";
+var uArr = "⇑";
+var Uarrocir = "⥉";
+var Ubrcy = "Ў";
+var ubrcy = "ў";
+var Ubreve = "Ŭ";
+var ubreve = "ŭ";
+var Ucirc$1 = "Û";
+var ucirc$1 = "û";
+var Ucy = "У";
+var ucy = "у";
+var udarr = "⇅";
+var Udblac = "Ű";
+var udblac = "ű";
+var udhar = "⥮";
+var ufisht = "⥾";
+var Ufr = "𝔘";
+var ufr = "𝔲";
+var Ugrave$1 = "Ù";
+var ugrave$1 = "ù";
+var uHar = "⥣";
+var uharl = "↿";
+var uharr = "↾";
+var uhblk = "▀";
+var ulcorn = "⌜";
+var ulcorner = "⌜";
+var ulcrop = "⌏";
+var ultri = "◸";
+var Umacr = "Ū";
+var umacr = "ū";
+var uml$1 = "¨";
+var UnderBar = "_";
+var UnderBrace = "⏟";
+var UnderBracket = "⎵";
+var UnderParenthesis = "⏝";
+var Union = "⋃";
+var UnionPlus = "⊎";
+var Uogon = "Ų";
+var uogon = "ų";
+var Uopf = "𝕌";
+var uopf = "𝕦";
+var UpArrowBar = "⤒";
+var uparrow = "↑";
+var UpArrow = "↑";
+var Uparrow = "⇑";
+var UpArrowDownArrow = "⇅";
+var updownarrow = "↕";
+var UpDownArrow = "↕";
+var Updownarrow = "⇕";
+var UpEquilibrium = "⥮";
+var upharpoonleft = "↿";
+var upharpoonright = "↾";
+var uplus = "⊎";
+var UpperLeftArrow = "↖";
+var UpperRightArrow = "↗";
+var upsi = "υ";
+var Upsi = "ϒ";
+var upsih = "ϒ";
+var Upsilon = "Υ";
+var upsilon = "υ";
+var UpTeeArrow = "↥";
+var UpTee = "⊥";
+var upuparrows = "⇈";
+var urcorn = "⌝";
+var urcorner = "⌝";
+var urcrop = "⌎";
+var Uring = "Ů";
+var uring = "ů";
+var urtri = "◹";
+var Uscr = "𝒰";
+var uscr = "𝓊";
+var utdot = "⋰";
+var Utilde = "Ũ";
+var utilde = "ũ";
+var utri = "▵";
+var utrif = "▴";
+var uuarr = "⇈";
+var Uuml$1 = "Ü";
+var uuml$1 = "ü";
+var uwangle = "⦧";
+var vangrt = "⦜";
+var varepsilon = "ϵ";
+var varkappa = "ϰ";
+var varnothing = "∅";
+var varphi = "ϕ";
+var varpi = "ϖ";
+var varpropto = "∝";
+var varr = "↕";
+var vArr = "⇕";
+var varrho = "ϱ";
+var varsigma = "ς";
+var varsubsetneq = "⊊︀";
+var varsubsetneqq = "⫋︀";
+var varsupsetneq = "⊋︀";
+var varsupsetneqq = "⫌︀";
+var vartheta = "ϑ";
+var vartriangleleft = "⊲";
+var vartriangleright = "⊳";
+var vBar = "⫨";
+var Vbar = "⫫";
+var vBarv = "⫩";
+var Vcy = "В";
+var vcy = "в";
+var vdash = "⊢";
+var vDash = "⊨";
+var Vdash = "⊩";
+var VDash = "⊫";
+var Vdashl = "⫦";
+var veebar = "⊻";
+var vee = "∨";
+var Vee = "⋁";
+var veeeq = "≚";
+var vellip = "⋮";
+var verbar = "|";
+var Verbar = "‖";
+var vert = "|";
+var Vert = "‖";
+var VerticalBar = "∣";
+var VerticalLine = "|";
+var VerticalSeparator = "❘";
+var VerticalTilde = "≀";
+var VeryThinSpace = " ";
+var Vfr = "𝔙";
+var vfr = "𝔳";
+var vltri = "⊲";
+var vnsub = "⊂⃒";
+var vnsup = "⊃⃒";
+var Vopf = "𝕍";
+var vopf = "𝕧";
+var vprop = "∝";
+var vrtri = "⊳";
+var Vscr = "𝒱";
+var vscr = "𝓋";
+var vsubnE = "⫋︀";
+var vsubne = "⊊︀";
+var vsupnE = "⫌︀";
+var vsupne = "⊋︀";
+var Vvdash = "⊪";
+var vzigzag = "⦚";
+var Wcirc = "Ŵ";
+var wcirc = "ŵ";
+var wedbar = "⩟";
+var wedge = "∧";
+var Wedge = "⋀";
+var wedgeq = "≙";
+var weierp = "℘";
+var Wfr = "𝔚";
+var wfr = "𝔴";
+var Wopf = "𝕎";
+var wopf = "𝕨";
+var wp = "℘";
+var wr = "≀";
+var wreath = "≀";
+var Wscr = "𝒲";
+var wscr = "𝓌";
+var xcap = "⋂";
+var xcirc = "◯";
+var xcup = "⋃";
+var xdtri = "▽";
+var Xfr = "𝔛";
+var xfr = "𝔵";
+var xharr = "⟷";
+var xhArr = "⟺";
+var Xi = "Ξ";
+var xi = "ξ";
+var xlarr = "⟵";
+var xlArr = "⟸";
+var xmap = "⟼";
+var xnis = "⋻";
+var xodot = "⨀";
+var Xopf = "𝕏";
+var xopf = "𝕩";
+var xoplus = "⨁";
+var xotime = "⨂";
+var xrarr = "⟶";
+var xrArr = "⟹";
+var Xscr = "𝒳";
+var xscr = "𝓍";
+var xsqcup = "⨆";
+var xuplus = "⨄";
+var xutri = "△";
+var xvee = "⋁";
+var xwedge = "⋀";
+var Yacute$1 = "Ý";
+var yacute$1 = "ý";
+var YAcy = "Я";
+var yacy = "я";
+var Ycirc = "Ŷ";
+var ycirc = "ŷ";
+var Ycy = "Ы";
+var ycy = "ы";
+var yen$1 = "¥";
+var Yfr = "𝔜";
+var yfr = "𝔶";
+var YIcy = "Ї";
+var yicy = "ї";
+var Yopf = "𝕐";
+var yopf = "𝕪";
+var Yscr = "𝒴";
+var yscr = "𝓎";
+var YUcy = "Ю";
+var yucy = "ю";
+var yuml$1 = "ÿ";
+var Yuml = "Ÿ";
+var Zacute = "Ź";
+var zacute = "ź";
+var Zcaron = "Ž";
+var zcaron = "ž";
+var Zcy = "З";
+var zcy = "з";
+var Zdot = "Ż";
+var zdot = "ż";
+var zeetrf = "ℨ";
+var ZeroWidthSpace = "";
+var Zeta = "Ζ";
+var zeta = "ζ";
+var zfr = "𝔷";
+var Zfr = "ℨ";
+var ZHcy = "Ж";
+var zhcy = "ж";
+var zigrarr = "⇝";
+var zopf = "𝕫";
+var Zopf = "ℤ";
+var Zscr = "𝒵";
+var zscr = "𝓏";
+var zwj = "";
+var zwnj = "";
+var require$$1$1 = {
+ Aacute: Aacute$1,
+ aacute: aacute$1,
+ Abreve: Abreve,
+ abreve: abreve,
+ ac: ac,
+ acd: acd,
+ acE: acE,
+ Acirc: Acirc$1,
+ acirc: acirc$1,
+ acute: acute$1,
+ Acy: Acy,
+ acy: acy,
+ AElig: AElig$1,
+ aelig: aelig$1,
+ af: af,
+ Afr: Afr,
+ afr: afr,
+ Agrave: Agrave$1,
+ agrave: agrave$1,
+ alefsym: alefsym,
+ aleph: aleph,
+ Alpha: Alpha,
+ alpha: alpha,
+ Amacr: Amacr,
+ amacr: amacr,
+ amalg: amalg,
+ amp: amp$2,
+ AMP: AMP$1,
+ andand: andand,
+ And: And,
+ and: and,
+ andd: andd,
+ andslope: andslope,
+ andv: andv,
+ ang: ang,
+ ange: ange,
+ angle: angle,
+ angmsdaa: angmsdaa,
+ angmsdab: angmsdab,
+ angmsdac: angmsdac,
+ angmsdad: angmsdad,
+ angmsdae: angmsdae,
+ angmsdaf: angmsdaf,
+ angmsdag: angmsdag,
+ angmsdah: angmsdah,
+ angmsd: angmsd,
+ angrt: angrt,
+ angrtvb: angrtvb,
+ angrtvbd: angrtvbd,
+ angsph: angsph,
+ angst: angst,
+ angzarr: angzarr,
+ Aogon: Aogon,
+ aogon: aogon,
+ Aopf: Aopf,
+ aopf: aopf,
+ apacir: apacir,
+ ap: ap,
+ apE: apE,
+ ape: ape,
+ apid: apid,
+ apos: apos$1,
+ ApplyFunction: ApplyFunction,
+ approx: approx,
+ approxeq: approxeq,
+ Aring: Aring$1,
+ aring: aring$1,
+ Ascr: Ascr,
+ ascr: ascr,
+ Assign: Assign,
+ ast: ast,
+ asymp: asymp,
+ asympeq: asympeq,
+ Atilde: Atilde$1,
+ atilde: atilde$1,
+ Auml: Auml$1,
+ auml: auml$1,
+ awconint: awconint,
+ awint: awint,
+ backcong: backcong,
+ backepsilon: backepsilon,
+ backprime: backprime,
+ backsim: backsim,
+ backsimeq: backsimeq,
+ Backslash: Backslash,
+ Barv: Barv,
+ barvee: barvee,
+ barwed: barwed,
+ Barwed: Barwed,
+ barwedge: barwedge,
+ bbrk: bbrk,
+ bbrktbrk: bbrktbrk,
+ bcong: bcong,
+ Bcy: Bcy,
+ bcy: bcy,
+ bdquo: bdquo,
+ becaus: becaus,
+ because: because,
+ Because: Because,
+ bemptyv: bemptyv,
+ bepsi: bepsi,
+ bernou: bernou,
+ Bernoullis: Bernoullis,
+ Beta: Beta,
+ beta: beta,
+ beth: beth,
+ between: esm_between,
+ Bfr: Bfr,
+ bfr: bfr,
+ bigcap: bigcap,
+ bigcirc: bigcirc,
+ bigcup: bigcup,
+ bigodot: bigodot,
+ bigoplus: bigoplus,
+ bigotimes: bigotimes,
+ bigsqcup: bigsqcup,
+ bigstar: bigstar,
+ bigtriangledown: bigtriangledown,
+ bigtriangleup: bigtriangleup,
+ biguplus: biguplus,
+ bigvee: bigvee,
+ bigwedge: bigwedge,
+ bkarow: bkarow,
+ blacklozenge: blacklozenge,
+ blacksquare: blacksquare,
+ blacktriangle: blacktriangle,
+ blacktriangledown: blacktriangledown,
+ blacktriangleleft: blacktriangleleft,
+ blacktriangleright: blacktriangleright,
+ blank: blank,
+ blk12: blk12,
+ blk14: blk14,
+ blk34: blk34,
+ block: block,
+ bne: bne,
+ bnequiv: bnequiv,
+ bNot: bNot,
+ bnot: bnot,
+ Bopf: Bopf,
+ bopf: bopf,
+ bot: bot,
+ bottom: bottom,
+ bowtie: bowtie,
+ boxbox: boxbox,
+ boxdl: boxdl,
+ boxdL: boxdL,
+ boxDl: boxDl,
+ boxDL: boxDL,
+ boxdr: boxdr,
+ boxdR: boxdR,
+ boxDr: boxDr,
+ boxDR: boxDR,
+ boxh: boxh,
+ boxH: boxH,
+ boxhd: boxhd,
+ boxHd: boxHd,
+ boxhD: boxhD,
+ boxHD: boxHD,
+ boxhu: boxhu,
+ boxHu: boxHu,
+ boxhU: boxhU,
+ boxHU: boxHU,
+ boxminus: boxminus,
+ boxplus: boxplus,
+ boxtimes: boxtimes,
+ boxul: boxul,
+ boxuL: boxuL,
+ boxUl: boxUl,
+ boxUL: boxUL,
+ boxur: boxur,
+ boxuR: boxuR,
+ boxUr: boxUr,
+ boxUR: boxUR,
+ boxv: boxv,
+ boxV: boxV,
+ boxvh: boxvh,
+ boxvH: boxvH,
+ boxVh: boxVh,
+ boxVH: boxVH,
+ boxvl: boxvl,
+ boxvL: boxvL,
+ boxVl: boxVl,
+ boxVL: boxVL,
+ boxvr: boxvr,
+ boxvR: boxvR,
+ boxVr: boxVr,
+ boxVR: boxVR,
+ bprime: bprime,
+ breve: breve,
+ Breve: Breve,
+ brvbar: brvbar$1,
+ bscr: bscr,
+ Bscr: Bscr,
+ bsemi: bsemi,
+ bsim: bsim,
+ bsime: bsime,
+ bsolb: bsolb,
+ bsol: bsol,
+ bsolhsub: bsolhsub,
+ bull: bull,
+ bullet: bullet,
+ bump: bump,
+ bumpE: bumpE,
+ bumpe: bumpe,
+ Bumpeq: Bumpeq,
+ bumpeq: bumpeq,
+ Cacute: Cacute,
+ cacute: cacute,
+ capand: capand,
+ capbrcup: capbrcup,
+ capcap: capcap,
+ cap: cap,
+ Cap: Cap,
+ capcup: capcup,
+ capdot: capdot,
+ CapitalDifferentialD: CapitalDifferentialD,
+ caps: caps,
+ caret: caret,
+ caron: caron,
+ Cayleys: Cayleys,
+ ccaps: ccaps,
+ Ccaron: Ccaron,
+ ccaron: ccaron,
+ Ccedil: Ccedil$1,
+ ccedil: ccedil$1,
+ Ccirc: Ccirc,
+ ccirc: ccirc,
+ Cconint: Cconint,
+ ccups: ccups,
+ ccupssm: ccupssm,
+ Cdot: Cdot,
+ cdot: cdot,
+ cedil: cedil$1,
+ Cedilla: Cedilla,
+ cemptyv: cemptyv,
+ cent: cent$1,
+ centerdot: centerdot,
+ CenterDot: CenterDot,
+ cfr: cfr,
+ Cfr: Cfr,
+ CHcy: CHcy,
+ chcy: chcy,
+ check: check,
+ checkmark: checkmark,
+ Chi: Chi,
+ chi: chi,
+ circ: circ,
+ circeq: circeq,
+ circlearrowleft: circlearrowleft,
+ circlearrowright: circlearrowright,
+ circledast: circledast,
+ circledcirc: circledcirc,
+ circleddash: circleddash,
+ CircleDot: CircleDot,
+ circledR: circledR,
+ circledS: circledS,
+ CircleMinus: CircleMinus,
+ CirclePlus: CirclePlus,
+ CircleTimes: CircleTimes,
+ cir: cir,
+ cirE: cirE,
+ cire: cire,
+ cirfnint: cirfnint,
+ cirmid: cirmid,
+ cirscir: cirscir,
+ ClockwiseContourIntegral: ClockwiseContourIntegral,
+ CloseCurlyDoubleQuote: CloseCurlyDoubleQuote,
+ CloseCurlyQuote: CloseCurlyQuote,
+ clubs: clubs,
+ clubsuit: clubsuit,
+ colon: colon,
+ Colon: Colon,
+ Colone: Colone,
+ colone: colone,
+ coloneq: coloneq,
+ comma: comma,
+ commat: commat,
+ comp: comp,
+ compfn: compfn,
+ complement: complement,
+ complexes: complexes,
+ cong: cong,
+ congdot: congdot,
+ Congruent: Congruent,
+ conint: conint,
+ Conint: Conint,
+ ContourIntegral: ContourIntegral,
+ copf: copf,
+ Copf: Copf,
+ coprod: coprod,
+ Coproduct: Coproduct,
+ copy: copy$1,
+ COPY: COPY$1,
+ copysr: copysr,
+ CounterClockwiseContourIntegral: CounterClockwiseContourIntegral,
+ crarr: crarr,
+ cross: cross,
+ Cross: Cross,
+ Cscr: Cscr,
+ cscr: cscr,
+ csub: csub,
+ csube: csube,
+ csup: csup,
+ csupe: csupe,
+ ctdot: ctdot,
+ cudarrl: cudarrl,
+ cudarrr: cudarrr,
+ cuepr: cuepr,
+ cuesc: cuesc,
+ cularr: cularr,
+ cularrp: cularrp,
+ cupbrcap: cupbrcap,
+ cupcap: cupcap,
+ CupCap: CupCap,
+ cup: cup,
+ Cup: Cup,
+ cupcup: cupcup,
+ cupdot: cupdot,
+ cupor: cupor,
+ cups: cups,
+ curarr: curarr,
+ curarrm: curarrm,
+ curlyeqprec: curlyeqprec,
+ curlyeqsucc: curlyeqsucc,
+ curlyvee: curlyvee,
+ curlywedge: curlywedge,
+ curren: curren$1,
+ curvearrowleft: curvearrowleft,
+ curvearrowright: curvearrowright,
+ cuvee: cuvee,
+ cuwed: cuwed,
+ cwconint: cwconint,
+ cwint: cwint,
+ cylcty: cylcty,
+ dagger: dagger,
+ Dagger: Dagger,
+ daleth: daleth,
+ darr: darr,
+ Darr: Darr,
+ dArr: dArr,
+ dash: dash,
+ Dashv: Dashv,
+ dashv: dashv,
+ dbkarow: dbkarow,
+ dblac: dblac,
+ Dcaron: Dcaron,
+ dcaron: dcaron,
+ Dcy: Dcy,
+ dcy: dcy,
+ ddagger: ddagger,
+ ddarr: ddarr,
+ DD: DD,
+ dd: dd,
+ DDotrahd: DDotrahd,
+ ddotseq: ddotseq,
+ deg: deg$1,
+ Del: Del,
+ Delta: Delta,
+ delta: delta,
+ demptyv: demptyv,
+ dfisht: dfisht,
+ Dfr: Dfr,
+ dfr: dfr,
+ dHar: dHar,
+ dharl: dharl,
+ dharr: dharr,
+ DiacriticalAcute: DiacriticalAcute,
+ DiacriticalDot: DiacriticalDot,
+ DiacriticalDoubleAcute: DiacriticalDoubleAcute,
+ DiacriticalGrave: DiacriticalGrave,
+ DiacriticalTilde: DiacriticalTilde,
+ diam: diam,
+ diamond: diamond,
+ Diamond: Diamond,
+ diamondsuit: diamondsuit,
+ diams: diams,
+ die: die,
+ DifferentialD: DifferentialD,
+ digamma: digamma,
+ disin: disin,
+ div: div,
+ divide: divide$1,
+ divideontimes: divideontimes,
+ divonx: divonx,
+ DJcy: DJcy,
+ djcy: djcy,
+ dlcorn: dlcorn,
+ dlcrop: dlcrop,
+ dollar: dollar,
+ Dopf: Dopf,
+ dopf: dopf,
+ Dot: Dot,
+ dot: dot,
+ DotDot: DotDot,
+ doteq: doteq,
+ doteqdot: doteqdot,
+ DotEqual: DotEqual,
+ dotminus: dotminus,
+ dotplus: dotplus,
+ dotsquare: dotsquare,
+ doublebarwedge: doublebarwedge,
+ DoubleContourIntegral: DoubleContourIntegral,
+ DoubleDot: DoubleDot,
+ DoubleDownArrow: DoubleDownArrow,
+ DoubleLeftArrow: DoubleLeftArrow,
+ DoubleLeftRightArrow: DoubleLeftRightArrow,
+ DoubleLeftTee: DoubleLeftTee,
+ DoubleLongLeftArrow: DoubleLongLeftArrow,
+ DoubleLongLeftRightArrow: DoubleLongLeftRightArrow,
+ DoubleLongRightArrow: DoubleLongRightArrow,
+ DoubleRightArrow: DoubleRightArrow,
+ DoubleRightTee: DoubleRightTee,
+ DoubleUpArrow: DoubleUpArrow,
+ DoubleUpDownArrow: DoubleUpDownArrow,
+ DoubleVerticalBar: DoubleVerticalBar,
+ DownArrowBar: DownArrowBar,
+ downarrow: downarrow,
+ DownArrow: DownArrow,
+ Downarrow: Downarrow,
+ DownArrowUpArrow: DownArrowUpArrow,
+ DownBreve: DownBreve,
+ downdownarrows: downdownarrows,
+ downharpoonleft: downharpoonleft,
+ downharpoonright: downharpoonright,
+ DownLeftRightVector: DownLeftRightVector,
+ DownLeftTeeVector: DownLeftTeeVector,
+ DownLeftVectorBar: DownLeftVectorBar,
+ DownLeftVector: DownLeftVector,
+ DownRightTeeVector: DownRightTeeVector,
+ DownRightVectorBar: DownRightVectorBar,
+ DownRightVector: DownRightVector,
+ DownTeeArrow: DownTeeArrow,
+ DownTee: DownTee,
+ drbkarow: drbkarow,
+ drcorn: drcorn,
+ drcrop: drcrop,
+ Dscr: Dscr,
+ dscr: dscr,
+ DScy: DScy,
+ dscy: dscy,
+ dsol: dsol,
+ Dstrok: Dstrok,
+ dstrok: dstrok,
+ dtdot: dtdot,
+ dtri: dtri,
+ dtrif: dtrif,
+ duarr: duarr,
+ duhar: duhar,
+ dwangle: dwangle,
+ DZcy: DZcy,
+ dzcy: dzcy,
+ dzigrarr: dzigrarr,
+ Eacute: Eacute$1,
+ eacute: eacute$1,
+ easter: easter,
+ Ecaron: Ecaron,
+ ecaron: ecaron,
+ Ecirc: Ecirc$1,
+ ecirc: ecirc$1,
+ ecir: ecir,
+ ecolon: ecolon,
+ Ecy: Ecy,
+ ecy: ecy,
+ eDDot: eDDot,
+ Edot: Edot,
+ edot: edot,
+ eDot: eDot,
+ ee: ee,
+ efDot: efDot,
+ Efr: Efr,
+ efr: efr,
+ eg: eg,
+ Egrave: Egrave$1,
+ egrave: egrave$1,
+ egs: egs,
+ egsdot: egsdot,
+ el: el,
+ Element: esm_Element,
+ elinters: elinters,
+ ell: ell,
+ els: els,
+ elsdot: elsdot,
+ Emacr: Emacr,
+ emacr: emacr,
+ empty: esm_empty,
+ emptyset: emptyset,
+ EmptySmallSquare: EmptySmallSquare,
+ emptyv: emptyv,
+ EmptyVerySmallSquare: EmptyVerySmallSquare,
+ emsp13: emsp13,
+ emsp14: emsp14,
+ emsp: emsp,
+ ENG: ENG,
+ eng: eng,
+ ensp: ensp,
+ Eogon: Eogon,
+ eogon: eogon,
+ Eopf: Eopf,
+ eopf: eopf,
+ epar: epar,
+ eparsl: eparsl,
+ eplus: eplus,
+ epsi: epsi,
+ Epsilon: Epsilon,
+ epsilon: epsilon,
+ epsiv: epsiv,
+ eqcirc: eqcirc,
+ eqcolon: eqcolon,
+ eqsim: eqsim,
+ eqslantgtr: eqslantgtr,
+ eqslantless: eqslantless,
+ Equal: Equal,
+ equals: equals,
+ EqualTilde: EqualTilde,
+ equest: equest,
+ Equilibrium: Equilibrium,
+ equiv: equiv,
+ equivDD: equivDD,
+ eqvparsl: eqvparsl,
+ erarr: erarr,
+ erDot: erDot,
+ escr: escr,
+ Escr: Escr,
+ esdot: esdot,
+ Esim: Esim,
+ esim: esim,
+ Eta: Eta,
+ eta: eta,
+ ETH: ETH$1,
+ eth: eth$1,
+ Euml: Euml$1,
+ euml: euml$1,
+ euro: euro,
+ excl: excl,
+ exist: exist,
+ Exists: Exists,
+ expectation: expectation,
+ exponentiale: exponentiale,
+ ExponentialE: ExponentialE,
+ fallingdotseq: fallingdotseq,
+ Fcy: Fcy,
+ fcy: fcy,
+ female: female,
+ ffilig: ffilig,
+ fflig: fflig,
+ ffllig: ffllig,
+ Ffr: Ffr,
+ ffr: ffr,
+ filig: filig,
+ FilledSmallSquare: FilledSmallSquare,
+ FilledVerySmallSquare: FilledVerySmallSquare,
+ fjlig: fjlig,
+ flat: flat,
+ fllig: fllig,
+ fltns: fltns,
+ fnof: fnof,
+ Fopf: Fopf,
+ fopf: fopf,
+ forall: forall,
+ ForAll: ForAll,
+ fork: fork,
+ forkv: forkv,
+ Fouriertrf: Fouriertrf,
+ fpartint: fpartint,
+ frac12: frac12$1,
+ frac13: frac13,
+ frac14: frac14$1,
+ frac15: frac15,
+ frac16: frac16,
+ frac18: frac18,
+ frac23: frac23,
+ frac25: frac25,
+ frac34: frac34$1,
+ frac35: frac35,
+ frac38: frac38,
+ frac45: frac45,
+ frac56: frac56,
+ frac58: frac58,
+ frac78: frac78,
+ frasl: frasl,
+ frown: frown,
+ fscr: fscr,
+ Fscr: Fscr,
+ gacute: gacute,
+ Gamma: Gamma,
+ gamma: gamma,
+ Gammad: Gammad,
+ gammad: gammad,
+ gap: gap,
+ Gbreve: Gbreve,
+ gbreve: gbreve,
+ Gcedil: Gcedil,
+ Gcirc: Gcirc,
+ gcirc: gcirc,
+ Gcy: Gcy,
+ gcy: gcy,
+ Gdot: Gdot,
+ gdot: gdot,
+ ge: ge,
+ gE: gE,
+ gEl: gEl,
+ gel: gel,
+ geq: geq,
+ geqq: geqq,
+ geqslant: geqslant,
+ gescc: gescc,
+ ges: ges,
+ gesdot: gesdot,
+ gesdoto: gesdoto,
+ gesdotol: gesdotol,
+ gesl: gesl,
+ gesles: gesles,
+ Gfr: Gfr,
+ gfr: gfr,
+ gg: gg,
+ Gg: Gg,
+ ggg: ggg,
+ gimel: gimel,
+ GJcy: GJcy,
+ gjcy: gjcy,
+ gla: gla,
+ gl: gl,
+ glE: glE,
+ glj: glj,
+ gnap: gnap,
+ gnapprox: gnapprox,
+ gne: gne,
+ gnE: gnE,
+ gneq: gneq,
+ gneqq: gneqq,
+ gnsim: gnsim,
+ Gopf: Gopf,
+ gopf: gopf,
+ grave: grave,
+ GreaterEqual: GreaterEqual,
+ GreaterEqualLess: GreaterEqualLess,
+ GreaterFullEqual: GreaterFullEqual,
+ GreaterGreater: GreaterGreater,
+ GreaterLess: GreaterLess,
+ GreaterSlantEqual: GreaterSlantEqual,
+ GreaterTilde: GreaterTilde,
+ Gscr: Gscr,
+ gscr: gscr,
+ gsim: gsim,
+ gsime: gsime,
+ gsiml: gsiml,
+ gtcc: gtcc,
+ gtcir: gtcir,
+ gt: gt$2,
+ GT: GT$1,
+ Gt: Gt,
+ gtdot: gtdot,
+ gtlPar: gtlPar,
+ gtquest: gtquest,
+ gtrapprox: gtrapprox,
+ gtrarr: gtrarr,
+ gtrdot: gtrdot,
+ gtreqless: gtreqless,
+ gtreqqless: gtreqqless,
+ gtrless: gtrless,
+ gtrsim: gtrsim,
+ gvertneqq: gvertneqq,
+ gvnE: gvnE,
+ Hacek: Hacek,
+ hairsp: hairsp,
+ half: half,
+ hamilt: hamilt,
+ HARDcy: HARDcy,
+ hardcy: hardcy,
+ harrcir: harrcir,
+ harr: harr,
+ hArr: hArr,
+ harrw: harrw,
+ Hat: Hat,
+ hbar: hbar,
+ Hcirc: Hcirc,
+ hcirc: hcirc,
+ hearts: hearts,
+ heartsuit: heartsuit,
+ hellip: hellip,
+ hercon: hercon,
+ hfr: hfr,
+ Hfr: Hfr,
+ HilbertSpace: HilbertSpace,
+ hksearow: hksearow,
+ hkswarow: hkswarow,
+ hoarr: hoarr,
+ homtht: homtht,
+ hookleftarrow: hookleftarrow,
+ hookrightarrow: hookrightarrow,
+ hopf: hopf,
+ Hopf: Hopf,
+ horbar: horbar,
+ HorizontalLine: HorizontalLine,
+ hscr: hscr,
+ Hscr: Hscr,
+ hslash: hslash,
+ Hstrok: Hstrok,
+ hstrok: hstrok,
+ HumpDownHump: HumpDownHump,
+ HumpEqual: HumpEqual,
+ hybull: hybull,
+ hyphen: hyphen,
+ Iacute: Iacute$1,
+ iacute: iacute$1,
+ ic: ic,
+ Icirc: Icirc$1,
+ icirc: icirc$1,
+ Icy: Icy,
+ icy: icy,
+ Idot: Idot,
+ IEcy: IEcy,
+ iecy: iecy,
+ iexcl: iexcl$1,
+ iff: iff,
+ ifr: ifr,
+ Ifr: Ifr,
+ Igrave: Igrave$1,
+ igrave: igrave$1,
+ ii: ii,
+ iiiint: iiiint,
+ iiint: iiint,
+ iinfin: iinfin,
+ iiota: iiota,
+ IJlig: IJlig,
+ ijlig: ijlig,
+ Imacr: Imacr,
+ imacr: imacr,
+ image: esm_image,
+ ImaginaryI: ImaginaryI,
+ imagline: imagline,
+ imagpart: imagpart,
+ imath: imath,
+ Im: Im,
+ imof: imof,
+ imped: imped,
+ Implies: Implies,
+ incare: incare,
+ "in": "∈",
+ infin: infin,
+ infintie: infintie,
+ inodot: inodot,
+ intcal: intcal,
+ int: esm_int,
+ Int: Int,
+ integers: integers,
+ Integral: Integral,
+ intercal: intercal,
+ Intersection: Intersection,
+ intlarhk: intlarhk,
+ intprod: intprod,
+ InvisibleComma: InvisibleComma,
+ InvisibleTimes: InvisibleTimes,
+ IOcy: IOcy,
+ iocy: iocy,
+ Iogon: Iogon,
+ iogon: iogon,
+ Iopf: Iopf,
+ iopf: iopf,
+ Iota: Iota,
+ iota: iota,
+ iprod: iprod,
+ iquest: iquest$1,
+ iscr: iscr,
+ Iscr: Iscr,
+ isin: isin,
+ isindot: isindot,
+ isinE: isinE,
+ isins: isins,
+ isinsv: isinsv,
+ isinv: isinv,
+ it: it,
+ Itilde: Itilde,
+ itilde: itilde,
+ Iukcy: Iukcy,
+ iukcy: iukcy,
+ Iuml: Iuml$1,
+ iuml: iuml$1,
+ Jcirc: Jcirc,
+ jcirc: jcirc,
+ Jcy: Jcy,
+ jcy: jcy,
+ Jfr: Jfr,
+ jfr: jfr,
+ jmath: jmath,
+ Jopf: Jopf,
+ jopf: jopf,
+ Jscr: Jscr,
+ jscr: jscr,
+ Jsercy: Jsercy,
+ jsercy: jsercy,
+ Jukcy: Jukcy,
+ jukcy: jukcy,
+ Kappa: Kappa,
+ kappa: kappa,
+ kappav: kappav,
+ Kcedil: Kcedil,
+ kcedil: kcedil,
+ Kcy: Kcy,
+ kcy: kcy,
+ Kfr: Kfr,
+ kfr: kfr,
+ kgreen: kgreen,
+ KHcy: KHcy,
+ khcy: khcy,
+ KJcy: KJcy,
+ kjcy: kjcy,
+ Kopf: Kopf,
+ kopf: kopf,
+ Kscr: Kscr,
+ kscr: kscr,
+ lAarr: lAarr,
+ Lacute: Lacute,
+ lacute: lacute,
+ laemptyv: laemptyv,
+ lagran: lagran,
+ Lambda: Lambda,
+ lambda: lambda,
+ lang: lang,
+ Lang: Lang,
+ langd: langd,
+ langle: langle,
+ lap: lap,
+ Laplacetrf: Laplacetrf,
+ laquo: laquo$1,
+ larrb: larrb,
+ larrbfs: larrbfs,
+ larr: larr,
+ Larr: Larr,
+ lArr: lArr,
+ larrfs: larrfs,
+ larrhk: larrhk,
+ larrlp: larrlp,
+ larrpl: larrpl,
+ larrsim: larrsim,
+ larrtl: larrtl,
+ latail: latail,
+ lAtail: lAtail,
+ lat: lat,
+ late: late,
+ lates: lates,
+ lbarr: lbarr,
+ lBarr: lBarr,
+ lbbrk: lbbrk,
+ lbrace: lbrace,
+ lbrack: lbrack,
+ lbrke: lbrke,
+ lbrksld: lbrksld,
+ lbrkslu: lbrkslu,
+ Lcaron: Lcaron,
+ lcaron: lcaron,
+ Lcedil: Lcedil,
+ lcedil: lcedil,
+ lceil: lceil,
+ lcub: lcub,
+ Lcy: Lcy,
+ lcy: lcy,
+ ldca: ldca,
+ ldquo: ldquo,
+ ldquor: ldquor,
+ ldrdhar: ldrdhar,
+ ldrushar: ldrushar,
+ ldsh: ldsh,
+ le: le,
+ lE: lE,
+ LeftAngleBracket: LeftAngleBracket,
+ LeftArrowBar: LeftArrowBar,
+ leftarrow: leftarrow,
+ LeftArrow: LeftArrow,
+ Leftarrow: Leftarrow,
+ LeftArrowRightArrow: LeftArrowRightArrow,
+ leftarrowtail: leftarrowtail,
+ LeftCeiling: LeftCeiling,
+ LeftDoubleBracket: LeftDoubleBracket,
+ LeftDownTeeVector: LeftDownTeeVector,
+ LeftDownVectorBar: LeftDownVectorBar,
+ LeftDownVector: LeftDownVector,
+ LeftFloor: LeftFloor,
+ leftharpoondown: leftharpoondown,
+ leftharpoonup: leftharpoonup,
+ leftleftarrows: leftleftarrows,
+ leftrightarrow: leftrightarrow,
+ LeftRightArrow: LeftRightArrow,
+ Leftrightarrow: Leftrightarrow,
+ leftrightarrows: leftrightarrows,
+ leftrightharpoons: leftrightharpoons,
+ leftrightsquigarrow: leftrightsquigarrow,
+ LeftRightVector: LeftRightVector,
+ LeftTeeArrow: LeftTeeArrow,
+ LeftTee: LeftTee,
+ LeftTeeVector: LeftTeeVector,
+ leftthreetimes: leftthreetimes,
+ LeftTriangleBar: LeftTriangleBar,
+ LeftTriangle: LeftTriangle,
+ LeftTriangleEqual: LeftTriangleEqual,
+ LeftUpDownVector: LeftUpDownVector,
+ LeftUpTeeVector: LeftUpTeeVector,
+ LeftUpVectorBar: LeftUpVectorBar,
+ LeftUpVector: LeftUpVector,
+ LeftVectorBar: LeftVectorBar,
+ LeftVector: LeftVector,
+ lEg: lEg,
+ leg: leg,
+ leq: leq,
+ leqq: leqq,
+ leqslant: leqslant,
+ lescc: lescc,
+ les: les,
+ lesdot: lesdot,
+ lesdoto: lesdoto,
+ lesdotor: lesdotor,
+ lesg: lesg,
+ lesges: lesges,
+ lessapprox: lessapprox,
+ lessdot: lessdot,
+ lesseqgtr: lesseqgtr,
+ lesseqqgtr: lesseqqgtr,
+ LessEqualGreater: LessEqualGreater,
+ LessFullEqual: LessFullEqual,
+ LessGreater: LessGreater,
+ lessgtr: lessgtr,
+ LessLess: LessLess,
+ lesssim: lesssim,
+ LessSlantEqual: LessSlantEqual,
+ LessTilde: LessTilde,
+ lfisht: lfisht,
+ lfloor: lfloor,
+ Lfr: Lfr,
+ lfr: lfr,
+ lg: lg,
+ lgE: lgE,
+ lHar: lHar,
+ lhard: lhard,
+ lharu: lharu,
+ lharul: lharul,
+ lhblk: lhblk,
+ LJcy: LJcy,
+ ljcy: ljcy,
+ llarr: llarr,
+ ll: ll,
+ Ll: Ll,
+ llcorner: llcorner,
+ Lleftarrow: Lleftarrow,
+ llhard: llhard,
+ lltri: lltri,
+ Lmidot: Lmidot,
+ lmidot: lmidot,
+ lmoustache: lmoustache,
+ lmoust: lmoust,
+ lnap: lnap,
+ lnapprox: lnapprox,
+ lne: lne,
+ lnE: lnE,
+ lneq: lneq,
+ lneqq: lneqq,
+ lnsim: lnsim,
+ loang: loang,
+ loarr: loarr,
+ lobrk: lobrk,
+ longleftarrow: longleftarrow,
+ LongLeftArrow: LongLeftArrow,
+ Longleftarrow: Longleftarrow,
+ longleftrightarrow: longleftrightarrow,
+ LongLeftRightArrow: LongLeftRightArrow,
+ Longleftrightarrow: Longleftrightarrow,
+ longmapsto: longmapsto,
+ longrightarrow: longrightarrow,
+ LongRightArrow: LongRightArrow,
+ Longrightarrow: Longrightarrow,
+ looparrowleft: looparrowleft,
+ looparrowright: looparrowright,
+ lopar: lopar,
+ Lopf: Lopf,
+ lopf: lopf,
+ loplus: loplus,
+ lotimes: lotimes,
+ lowast: lowast,
+ lowbar: lowbar,
+ LowerLeftArrow: LowerLeftArrow,
+ LowerRightArrow: LowerRightArrow,
+ loz: loz,
+ lozenge: lozenge,
+ lozf: lozf,
+ lpar: lpar,
+ lparlt: lparlt,
+ lrarr: lrarr,
+ lrcorner: lrcorner,
+ lrhar: lrhar,
+ lrhard: lrhard,
+ lrm: lrm,
+ lrtri: lrtri,
+ lsaquo: lsaquo,
+ lscr: lscr,
+ Lscr: Lscr,
+ lsh: lsh,
+ Lsh: Lsh,
+ lsim: lsim,
+ lsime: lsime,
+ lsimg: lsimg,
+ lsqb: lsqb,
+ lsquo: lsquo,
+ lsquor: lsquor,
+ Lstrok: Lstrok,
+ lstrok: lstrok,
+ ltcc: ltcc,
+ ltcir: ltcir,
+ lt: lt$2,
+ LT: LT$1,
+ Lt: Lt,
+ ltdot: ltdot,
+ lthree: lthree,
+ ltimes: ltimes,
+ ltlarr: ltlarr,
+ ltquest: ltquest,
+ ltri: ltri,
+ ltrie: ltrie,
+ ltrif: ltrif,
+ ltrPar: ltrPar,
+ lurdshar: lurdshar,
+ luruhar: luruhar,
+ lvertneqq: lvertneqq,
+ lvnE: lvnE,
+ macr: macr$1,
+ male: male,
+ malt: malt,
+ maltese: maltese,
+ "Map": "⤅",
+ map: map,
+ mapsto: mapsto,
+ mapstodown: mapstodown,
+ mapstoleft: mapstoleft,
+ mapstoup: mapstoup,
+ marker: marker,
+ mcomma: mcomma,
+ Mcy: Mcy,
+ mcy: mcy,
+ mdash: mdash,
+ mDDot: mDDot,
+ measuredangle: measuredangle,
+ MediumSpace: MediumSpace,
+ Mellintrf: Mellintrf,
+ Mfr: Mfr,
+ mfr: mfr,
+ mho: mho,
+ micro: micro$1,
+ midast: midast,
+ midcir: midcir,
+ mid: mid,
+ middot: middot$1,
+ minusb: minusb,
+ minus: minus,
+ minusd: minusd,
+ minusdu: minusdu,
+ MinusPlus: MinusPlus,
+ mlcp: mlcp,
+ mldr: mldr,
+ mnplus: mnplus,
+ models: models,
+ Mopf: Mopf,
+ mopf: mopf,
+ mp: mp,
+ mscr: mscr,
+ Mscr: Mscr,
+ mstpos: mstpos,
+ Mu: Mu,
+ mu: mu,
+ multimap: multimap,
+ mumap: mumap,
+ nabla: nabla,
+ Nacute: Nacute,
+ nacute: nacute,
+ nang: nang,
+ nap: nap,
+ napE: napE,
+ napid: napid,
+ napos: napos,
+ napprox: napprox,
+ natural: natural,
+ naturals: naturals,
+ natur: natur,
+ nbsp: nbsp$1,
+ nbump: nbump,
+ nbumpe: nbumpe,
+ ncap: ncap,
+ Ncaron: Ncaron,
+ ncaron: ncaron,
+ Ncedil: Ncedil,
+ ncedil: ncedil,
+ ncong: ncong,
+ ncongdot: ncongdot,
+ ncup: ncup,
+ Ncy: Ncy,
+ ncy: ncy,
+ ndash: ndash,
+ nearhk: nearhk,
+ nearr: nearr,
+ neArr: neArr,
+ nearrow: nearrow,
+ ne: ne,
+ nedot: nedot,
+ NegativeMediumSpace: NegativeMediumSpace,
+ NegativeThickSpace: NegativeThickSpace,
+ NegativeThinSpace: NegativeThinSpace,
+ NegativeVeryThinSpace: NegativeVeryThinSpace,
+ nequiv: nequiv,
+ nesear: nesear,
+ nesim: nesim,
+ NestedGreaterGreater: NestedGreaterGreater,
+ NestedLessLess: NestedLessLess,
+ NewLine: NewLine,
+ nexist: nexist,
+ nexists: nexists,
+ Nfr: Nfr,
+ nfr: nfr,
+ ngE: ngE,
+ nge: nge,
+ ngeq: ngeq,
+ ngeqq: ngeqq,
+ ngeqslant: ngeqslant,
+ nges: nges,
+ nGg: nGg,
+ ngsim: ngsim,
+ nGt: nGt,
+ ngt: ngt,
+ ngtr: ngtr,
+ nGtv: nGtv,
+ nharr: nharr,
+ nhArr: nhArr,
+ nhpar: nhpar,
+ ni: ni,
+ nis: nis,
+ nisd: nisd,
+ niv: niv,
+ NJcy: NJcy,
+ njcy: njcy,
+ nlarr: nlarr,
+ nlArr: nlArr,
+ nldr: nldr,
+ nlE: nlE,
+ nle: nle,
+ nleftarrow: nleftarrow,
+ nLeftarrow: nLeftarrow,
+ nleftrightarrow: nleftrightarrow,
+ nLeftrightarrow: nLeftrightarrow,
+ nleq: nleq,
+ nleqq: nleqq,
+ nleqslant: nleqslant,
+ nles: nles,
+ nless: nless,
+ nLl: nLl,
+ nlsim: nlsim,
+ nLt: nLt,
+ nlt: nlt,
+ nltri: nltri,
+ nltrie: nltrie,
+ nLtv: nLtv,
+ nmid: nmid,
+ NoBreak: NoBreak,
+ NonBreakingSpace: NonBreakingSpace,
+ nopf: nopf,
+ Nopf: Nopf,
+ Not: Not,
+ not: not$1,
+ NotCongruent: NotCongruent,
+ NotCupCap: NotCupCap,
+ NotDoubleVerticalBar: NotDoubleVerticalBar,
+ NotElement: NotElement,
+ NotEqual: NotEqual,
+ NotEqualTilde: NotEqualTilde,
+ NotExists: NotExists,
+ NotGreater: NotGreater,
+ NotGreaterEqual: NotGreaterEqual,
+ NotGreaterFullEqual: NotGreaterFullEqual,
+ NotGreaterGreater: NotGreaterGreater,
+ NotGreaterLess: NotGreaterLess,
+ NotGreaterSlantEqual: NotGreaterSlantEqual,
+ NotGreaterTilde: NotGreaterTilde,
+ NotHumpDownHump: NotHumpDownHump,
+ NotHumpEqual: NotHumpEqual,
+ notin: notin,
+ notindot: notindot,
+ notinE: notinE,
+ notinva: notinva,
+ notinvb: notinvb,
+ notinvc: notinvc,
+ NotLeftTriangleBar: NotLeftTriangleBar,
+ NotLeftTriangle: NotLeftTriangle,
+ NotLeftTriangleEqual: NotLeftTriangleEqual,
+ NotLess: NotLess,
+ NotLessEqual: NotLessEqual,
+ NotLessGreater: NotLessGreater,
+ NotLessLess: NotLessLess,
+ NotLessSlantEqual: NotLessSlantEqual,
+ NotLessTilde: NotLessTilde,
+ NotNestedGreaterGreater: NotNestedGreaterGreater,
+ NotNestedLessLess: NotNestedLessLess,
+ notni: notni,
+ notniva: notniva,
+ notnivb: notnivb,
+ notnivc: notnivc,
+ NotPrecedes: NotPrecedes,
+ NotPrecedesEqual: NotPrecedesEqual,
+ NotPrecedesSlantEqual: NotPrecedesSlantEqual,
+ NotReverseElement: NotReverseElement,
+ NotRightTriangleBar: NotRightTriangleBar,
+ NotRightTriangle: NotRightTriangle,
+ NotRightTriangleEqual: NotRightTriangleEqual,
+ NotSquareSubset: NotSquareSubset,
+ NotSquareSubsetEqual: NotSquareSubsetEqual,
+ NotSquareSuperset: NotSquareSuperset,
+ NotSquareSupersetEqual: NotSquareSupersetEqual,
+ NotSubset: NotSubset,
+ NotSubsetEqual: NotSubsetEqual,
+ NotSucceeds: NotSucceeds,
+ NotSucceedsEqual: NotSucceedsEqual,
+ NotSucceedsSlantEqual: NotSucceedsSlantEqual,
+ NotSucceedsTilde: NotSucceedsTilde,
+ NotSuperset: NotSuperset,
+ NotSupersetEqual: NotSupersetEqual,
+ NotTilde: NotTilde,
+ NotTildeEqual: NotTildeEqual,
+ NotTildeFullEqual: NotTildeFullEqual,
+ NotTildeTilde: NotTildeTilde,
+ NotVerticalBar: NotVerticalBar,
+ nparallel: nparallel,
+ npar: npar,
+ nparsl: nparsl,
+ npart: npart,
+ npolint: npolint,
+ npr: npr,
+ nprcue: nprcue,
+ nprec: nprec,
+ npreceq: npreceq,
+ npre: npre,
+ nrarrc: nrarrc,
+ nrarr: nrarr,
+ nrArr: nrArr,
+ nrarrw: nrarrw,
+ nrightarrow: nrightarrow,
+ nRightarrow: nRightarrow,
+ nrtri: nrtri,
+ nrtrie: nrtrie,
+ nsc: nsc,
+ nsccue: nsccue,
+ nsce: nsce,
+ Nscr: Nscr,
+ nscr: nscr,
+ nshortmid: nshortmid,
+ nshortparallel: nshortparallel,
+ nsim: nsim,
+ nsime: nsime,
+ nsimeq: nsimeq,
+ nsmid: nsmid,
+ nspar: nspar,
+ nsqsube: nsqsube,
+ nsqsupe: nsqsupe,
+ nsub: nsub,
+ nsubE: nsubE,
+ nsube: nsube,
+ nsubset: nsubset,
+ nsubseteq: nsubseteq,
+ nsubseteqq: nsubseteqq,
+ nsucc: nsucc,
+ nsucceq: nsucceq,
+ nsup: nsup,
+ nsupE: nsupE,
+ nsupe: nsupe,
+ nsupset: nsupset,
+ nsupseteq: nsupseteq,
+ nsupseteqq: nsupseteqq,
+ ntgl: ntgl,
+ Ntilde: Ntilde$1,
+ ntilde: ntilde$1,
+ ntlg: ntlg,
+ ntriangleleft: ntriangleleft,
+ ntrianglelefteq: ntrianglelefteq,
+ ntriangleright: ntriangleright,
+ ntrianglerighteq: ntrianglerighteq,
+ Nu: Nu,
+ nu: nu,
+ num: num,
+ numero: numero,
+ numsp: numsp,
+ nvap: nvap,
+ nvdash: nvdash,
+ nvDash: nvDash,
+ nVdash: nVdash,
+ nVDash: nVDash,
+ nvge: nvge,
+ nvgt: nvgt,
+ nvHarr: nvHarr,
+ nvinfin: nvinfin,
+ nvlArr: nvlArr,
+ nvle: nvle,
+ nvlt: nvlt,
+ nvltrie: nvltrie,
+ nvrArr: nvrArr,
+ nvrtrie: nvrtrie,
+ nvsim: nvsim,
+ nwarhk: nwarhk,
+ nwarr: nwarr,
+ nwArr: nwArr,
+ nwarrow: nwarrow,
+ nwnear: nwnear,
+ Oacute: Oacute$1,
+ oacute: oacute$1,
+ oast: oast,
+ Ocirc: Ocirc$1,
+ ocirc: ocirc$1,
+ ocir: ocir,
+ Ocy: Ocy,
+ ocy: ocy,
+ odash: odash,
+ Odblac: Odblac,
+ odblac: odblac,
+ odiv: odiv,
+ odot: odot,
+ odsold: odsold,
+ OElig: OElig,
+ oelig: oelig,
+ ofcir: ofcir,
+ Ofr: Ofr,
+ ofr: ofr,
+ ogon: ogon,
+ Ograve: Ograve$1,
+ ograve: ograve$1,
+ ogt: ogt,
+ ohbar: ohbar,
+ ohm: ohm,
+ oint: oint,
+ olarr: olarr,
+ olcir: olcir,
+ olcross: olcross,
+ oline: oline,
+ olt: olt,
+ Omacr: Omacr,
+ omacr: omacr,
+ Omega: Omega,
+ omega: omega,
+ Omicron: Omicron,
+ omicron: omicron,
+ omid: omid,
+ ominus: ominus,
+ Oopf: Oopf,
+ oopf: oopf,
+ opar: opar,
+ OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
+ OpenCurlyQuote: OpenCurlyQuote,
+ operp: operp,
+ oplus: oplus,
+ orarr: orarr,
+ Or: Or,
+ or: or,
+ ord: ord,
+ order: order,
+ orderof: orderof,
+ ordf: ordf$1,
+ ordm: ordm$1,
+ origof: origof,
+ oror: oror,
+ orslope: orslope,
+ orv: orv,
+ oS: oS,
+ Oscr: Oscr,
+ oscr: oscr,
+ Oslash: Oslash$1,
+ oslash: oslash$1,
+ osol: osol,
+ Otilde: Otilde$1,
+ otilde: otilde$1,
+ otimesas: otimesas,
+ Otimes: Otimes,
+ otimes: otimes,
+ Ouml: Ouml$1,
+ ouml: ouml$1,
+ ovbar: ovbar,
+ OverBar: OverBar,
+ OverBrace: OverBrace,
+ OverBracket: OverBracket,
+ OverParenthesis: OverParenthesis,
+ para: para$1,
+ parallel: parallel,
+ par: par,
+ parsim: parsim,
+ parsl: parsl,
+ part: part,
+ PartialD: PartialD,
+ Pcy: Pcy,
+ pcy: pcy,
+ percnt: percnt,
+ period: period,
+ permil: permil,
+ perp: perp,
+ pertenk: pertenk,
+ Pfr: Pfr,
+ pfr: pfr,
+ Phi: Phi,
+ phi: phi,
+ phiv: phiv,
+ phmmat: phmmat,
+ phone: phone,
+ Pi: Pi,
+ pi: pi,
+ pitchfork: pitchfork,
+ piv: piv,
+ planck: planck,
+ planckh: planckh,
+ plankv: plankv,
+ plusacir: plusacir,
+ plusb: plusb,
+ pluscir: pluscir,
+ plus: plus,
+ plusdo: plusdo,
+ plusdu: plusdu,
+ pluse: pluse,
+ PlusMinus: PlusMinus,
+ plusmn: plusmn$1,
+ plussim: plussim,
+ plustwo: plustwo,
+ pm: pm,
+ Poincareplane: Poincareplane,
+ pointint: pointint,
+ popf: popf,
+ Popf: Popf,
+ pound: pound$1,
+ prap: prap,
+ Pr: Pr,
+ pr: pr,
+ prcue: prcue,
+ precapprox: precapprox,
+ prec: prec,
+ preccurlyeq: preccurlyeq,
+ Precedes: Precedes,
+ PrecedesEqual: PrecedesEqual,
+ PrecedesSlantEqual: PrecedesSlantEqual,
+ PrecedesTilde: PrecedesTilde,
+ preceq: preceq,
+ precnapprox: precnapprox,
+ precneqq: precneqq,
+ precnsim: precnsim,
+ pre: pre,
+ prE: prE,
+ precsim: precsim,
+ prime: prime,
+ Prime: Prime,
+ primes: primes,
+ prnap: prnap,
+ prnE: prnE,
+ prnsim: prnsim,
+ prod: prod,
+ Product: Product,
+ profalar: profalar,
+ profline: profline,
+ profsurf: profsurf,
+ prop: prop,
+ Proportional: Proportional,
+ Proportion: Proportion,
+ propto: propto,
+ prsim: prsim,
+ prurel: prurel,
+ Pscr: Pscr,
+ pscr: pscr,
+ Psi: Psi,
+ psi: psi,
+ puncsp: puncsp,
+ Qfr: Qfr,
+ qfr: qfr,
+ qint: qint,
+ qopf: qopf,
+ Qopf: Qopf,
+ qprime: qprime,
+ Qscr: Qscr,
+ qscr: qscr,
+ quaternions: quaternions,
+ quatint: quatint,
+ quest: quest,
+ questeq: questeq,
+ quot: quot$2,
+ QUOT: QUOT$1,
+ rAarr: rAarr,
+ race: race,
+ Racute: Racute,
+ racute: racute,
+ radic: radic,
+ raemptyv: raemptyv,
+ rang: rang,
+ Rang: Rang,
+ rangd: rangd,
+ range: range,
+ rangle: rangle,
+ raquo: raquo$1,
+ rarrap: rarrap,
+ rarrb: rarrb,
+ rarrbfs: rarrbfs,
+ rarrc: rarrc,
+ rarr: rarr,
+ Rarr: Rarr,
+ rArr: rArr,
+ rarrfs: rarrfs,
+ rarrhk: rarrhk,
+ rarrlp: rarrlp,
+ rarrpl: rarrpl,
+ rarrsim: rarrsim,
+ Rarrtl: Rarrtl,
+ rarrtl: rarrtl,
+ rarrw: rarrw,
+ ratail: ratail,
+ rAtail: rAtail,
+ ratio: ratio,
+ rationals: rationals,
+ rbarr: rbarr,
+ rBarr: rBarr,
+ RBarr: RBarr,
+ rbbrk: rbbrk,
+ rbrace: rbrace,
+ rbrack: rbrack,
+ rbrke: rbrke,
+ rbrksld: rbrksld,
+ rbrkslu: rbrkslu,
+ Rcaron: Rcaron,
+ rcaron: rcaron,
+ Rcedil: Rcedil,
+ rcedil: rcedil,
+ rceil: rceil,
+ rcub: rcub,
+ Rcy: Rcy,
+ rcy: rcy,
+ rdca: rdca,
+ rdldhar: rdldhar,
+ rdquo: rdquo,
+ rdquor: rdquor,
+ rdsh: rdsh,
+ real: real,
+ realine: realine,
+ realpart: realpart,
+ reals: reals,
+ Re: Re,
+ rect: rect,
+ reg: reg$1,
+ REG: REG$1,
+ ReverseElement: ReverseElement,
+ ReverseEquilibrium: ReverseEquilibrium,
+ ReverseUpEquilibrium: ReverseUpEquilibrium,
+ rfisht: rfisht,
+ rfloor: rfloor,
+ rfr: rfr,
+ Rfr: Rfr,
+ rHar: rHar,
+ rhard: rhard,
+ rharu: rharu,
+ rharul: rharul,
+ Rho: Rho,
+ rho: rho,
+ rhov: rhov,
+ RightAngleBracket: RightAngleBracket,
+ RightArrowBar: RightArrowBar,
+ rightarrow: rightarrow,
+ RightArrow: RightArrow,
+ Rightarrow: Rightarrow,
+ RightArrowLeftArrow: RightArrowLeftArrow,
+ rightarrowtail: rightarrowtail,
+ RightCeiling: RightCeiling,
+ RightDoubleBracket: RightDoubleBracket,
+ RightDownTeeVector: RightDownTeeVector,
+ RightDownVectorBar: RightDownVectorBar,
+ RightDownVector: RightDownVector,
+ RightFloor: RightFloor,
+ rightharpoondown: rightharpoondown,
+ rightharpoonup: rightharpoonup,
+ rightleftarrows: rightleftarrows,
+ rightleftharpoons: rightleftharpoons,
+ rightrightarrows: rightrightarrows,
+ rightsquigarrow: rightsquigarrow,
+ RightTeeArrow: RightTeeArrow,
+ RightTee: RightTee,
+ RightTeeVector: RightTeeVector,
+ rightthreetimes: rightthreetimes,
+ RightTriangleBar: RightTriangleBar,
+ RightTriangle: RightTriangle,
+ RightTriangleEqual: RightTriangleEqual,
+ RightUpDownVector: RightUpDownVector,
+ RightUpTeeVector: RightUpTeeVector,
+ RightUpVectorBar: RightUpVectorBar,
+ RightUpVector: RightUpVector,
+ RightVectorBar: RightVectorBar,
+ RightVector: RightVector,
+ ring: ring,
+ risingdotseq: risingdotseq,
+ rlarr: rlarr,
+ rlhar: rlhar,
+ rlm: rlm,
+ rmoustache: rmoustache,
+ rmoust: rmoust,
+ rnmid: rnmid,
+ roang: roang,
+ roarr: roarr,
+ robrk: robrk,
+ ropar: ropar,
+ ropf: ropf,
+ Ropf: Ropf,
+ roplus: roplus,
+ rotimes: rotimes,
+ RoundImplies: RoundImplies,
+ rpar: rpar,
+ rpargt: rpargt,
+ rppolint: rppolint,
+ rrarr: rrarr,
+ Rrightarrow: Rrightarrow,
+ rsaquo: rsaquo,
+ rscr: rscr,
+ Rscr: Rscr,
+ rsh: rsh,
+ Rsh: Rsh,
+ rsqb: rsqb,
+ rsquo: rsquo,
+ rsquor: rsquor,
+ rthree: rthree,
+ rtimes: rtimes,
+ rtri: rtri,
+ rtrie: rtrie,
+ rtrif: rtrif,
+ rtriltri: rtriltri,
+ RuleDelayed: RuleDelayed,
+ ruluhar: ruluhar,
+ rx: rx,
+ Sacute: Sacute,
+ sacute: sacute,
+ sbquo: sbquo,
+ scap: scap,
+ Scaron: Scaron,
+ scaron: scaron,
+ Sc: Sc,
+ sc: sc,
+ sccue: sccue,
+ sce: sce,
+ scE: scE,
+ Scedil: Scedil,
+ scedil: scedil,
+ Scirc: Scirc,
+ scirc: scirc,
+ scnap: scnap,
+ scnE: scnE,
+ scnsim: scnsim,
+ scpolint: scpolint,
+ scsim: scsim,
+ Scy: Scy,
+ scy: scy,
+ sdotb: sdotb,
+ sdot: sdot,
+ sdote: sdote,
+ searhk: searhk,
+ searr: searr,
+ seArr: seArr,
+ searrow: searrow,
+ sect: sect$1,
+ semi: semi,
+ seswar: seswar,
+ setminus: setminus,
+ setmn: setmn,
+ sext: sext,
+ Sfr: Sfr,
+ sfr: sfr,
+ sfrown: sfrown,
+ sharp: sharp,
+ SHCHcy: SHCHcy,
+ shchcy: shchcy,
+ SHcy: SHcy,
+ shcy: shcy,
+ ShortDownArrow: ShortDownArrow,
+ ShortLeftArrow: ShortLeftArrow,
+ shortmid: shortmid,
+ shortparallel: shortparallel,
+ ShortRightArrow: ShortRightArrow,
+ ShortUpArrow: ShortUpArrow,
+ shy: shy$1,
+ Sigma: Sigma,
+ sigma: sigma,
+ sigmaf: sigmaf,
+ sigmav: sigmav,
+ sim: sim,
+ simdot: simdot,
+ sime: sime,
+ simeq: simeq,
+ simg: simg,
+ simgE: simgE,
+ siml: siml,
+ simlE: simlE,
+ simne: simne,
+ simplus: simplus,
+ simrarr: simrarr,
+ slarr: slarr,
+ SmallCircle: SmallCircle,
+ smallsetminus: smallsetminus,
+ smashp: smashp,
+ smeparsl: smeparsl,
+ smid: smid,
+ smile: smile,
+ smt: smt,
+ smte: smte,
+ smtes: smtes,
+ SOFTcy: SOFTcy,
+ softcy: softcy,
+ solbar: solbar,
+ solb: solb,
+ sol: sol,
+ Sopf: Sopf,
+ sopf: sopf,
+ spades: spades,
+ spadesuit: spadesuit,
+ spar: spar,
+ sqcap: sqcap,
+ sqcaps: sqcaps,
+ sqcup: sqcup,
+ sqcups: sqcups,
+ Sqrt: Sqrt,
+ sqsub: sqsub,
+ sqsube: sqsube,
+ sqsubset: sqsubset,
+ sqsubseteq: sqsubseteq,
+ sqsup: sqsup,
+ sqsupe: sqsupe,
+ sqsupset: sqsupset,
+ sqsupseteq: sqsupseteq,
+ square: square,
+ Square: Square,
+ SquareIntersection: SquareIntersection,
+ SquareSubset: SquareSubset,
+ SquareSubsetEqual: SquareSubsetEqual,
+ SquareSuperset: SquareSuperset,
+ SquareSupersetEqual: SquareSupersetEqual,
+ SquareUnion: SquareUnion,
+ squarf: squarf,
+ squ: squ,
+ squf: squf,
+ srarr: srarr,
+ Sscr: Sscr,
+ sscr: sscr,
+ ssetmn: ssetmn,
+ ssmile: ssmile,
+ sstarf: sstarf,
+ Star: Star,
+ star: star,
+ starf: starf,
+ straightepsilon: straightepsilon,
+ straightphi: straightphi,
+ strns: strns,
+ sub: sub,
+ Sub: Sub,
+ subdot: subdot,
+ subE: subE,
+ sube: sube,
+ subedot: subedot,
+ submult: submult,
+ subnE: subnE,
+ subne: subne,
+ subplus: subplus,
+ subrarr: subrarr,
+ subset: subset,
+ Subset: Subset,
+ subseteq: subseteq,
+ subseteqq: subseteqq,
+ SubsetEqual: SubsetEqual,
+ subsetneq: subsetneq,
+ subsetneqq: subsetneqq,
+ subsim: subsim,
+ subsub: subsub,
+ subsup: subsup,
+ succapprox: succapprox,
+ succ: succ,
+ succcurlyeq: succcurlyeq,
+ Succeeds: Succeeds,
+ SucceedsEqual: SucceedsEqual,
+ SucceedsSlantEqual: SucceedsSlantEqual,
+ SucceedsTilde: SucceedsTilde,
+ succeq: succeq,
+ succnapprox: succnapprox,
+ succneqq: succneqq,
+ succnsim: succnsim,
+ succsim: succsim,
+ SuchThat: SuchThat,
+ sum: sum,
+ Sum: Sum,
+ sung: sung,
+ sup1: sup1$1,
+ sup2: sup2$1,
+ sup3: sup3$1,
+ sup: sup,
+ Sup: Sup,
+ supdot: supdot,
+ supdsub: supdsub,
+ supE: supE,
+ supe: supe,
+ supedot: supedot,
+ Superset: Superset,
+ SupersetEqual: SupersetEqual,
+ suphsol: suphsol,
+ suphsub: suphsub,
+ suplarr: suplarr,
+ supmult: supmult,
+ supnE: supnE,
+ supne: supne,
+ supplus: supplus,
+ supset: supset,
+ Supset: Supset,
+ supseteq: supseteq,
+ supseteqq: supseteqq,
+ supsetneq: supsetneq,
+ supsetneqq: supsetneqq,
+ supsim: supsim,
+ supsub: supsub,
+ supsup: supsup,
+ swarhk: swarhk,
+ swarr: swarr,
+ swArr: swArr,
+ swarrow: swarrow,
+ swnwar: swnwar,
+ szlig: szlig$1,
+ Tab: Tab,
+ target: target,
+ Tau: Tau,
+ tau: tau,
+ tbrk: tbrk,
+ Tcaron: Tcaron,
+ tcaron: tcaron,
+ Tcedil: Tcedil,
+ tcedil: tcedil,
+ Tcy: Tcy,
+ tcy: tcy,
+ tdot: tdot,
+ telrec: telrec,
+ Tfr: Tfr,
+ tfr: tfr,
+ there4: there4,
+ therefore: therefore,
+ Therefore: Therefore,
+ Theta: Theta,
+ theta: theta,
+ thetasym: thetasym,
+ thetav: thetav,
+ thickapprox: thickapprox,
+ thicksim: thicksim,
+ ThickSpace: ThickSpace,
+ ThinSpace: ThinSpace,
+ thinsp: thinsp,
+ thkap: thkap,
+ thksim: thksim,
+ THORN: THORN$1,
+ thorn: thorn$1,
+ tilde: tilde,
+ Tilde: Tilde,
+ TildeEqual: TildeEqual,
+ TildeFullEqual: TildeFullEqual,
+ TildeTilde: TildeTilde,
+ timesbar: timesbar,
+ timesb: timesb,
+ times: times$1,
+ timesd: timesd,
+ tint: tint,
+ toea: toea,
+ topbot: topbot,
+ topcir: topcir,
+ top: esm_top,
+ Topf: Topf,
+ topf: topf,
+ topfork: topfork,
+ tosa: tosa,
+ tprime: tprime,
+ trade: trade,
+ TRADE: TRADE,
+ triangle: triangle,
+ triangledown: triangledown,
+ triangleleft: triangleleft,
+ trianglelefteq: trianglelefteq,
+ triangleq: triangleq,
+ triangleright: triangleright,
+ trianglerighteq: trianglerighteq,
+ tridot: tridot,
+ trie: trie,
+ triminus: triminus,
+ TripleDot: TripleDot,
+ triplus: triplus,
+ trisb: trisb,
+ tritime: tritime,
+ trpezium: trpezium,
+ Tscr: Tscr,
+ tscr: tscr,
+ TScy: TScy,
+ tscy: tscy,
+ TSHcy: TSHcy,
+ tshcy: tshcy,
+ Tstrok: Tstrok,
+ tstrok: tstrok,
+ twixt: twixt,
+ twoheadleftarrow: twoheadleftarrow,
+ twoheadrightarrow: twoheadrightarrow,
+ Uacute: Uacute$1,
+ uacute: uacute$1,
+ uarr: uarr,
+ Uarr: Uarr,
+ uArr: uArr,
+ Uarrocir: Uarrocir,
+ Ubrcy: Ubrcy,
+ ubrcy: ubrcy,
+ Ubreve: Ubreve,
+ ubreve: ubreve,
+ Ucirc: Ucirc$1,
+ ucirc: ucirc$1,
+ Ucy: Ucy,
+ ucy: ucy,
+ udarr: udarr,
+ Udblac: Udblac,
+ udblac: udblac,
+ udhar: udhar,
+ ufisht: ufisht,
+ Ufr: Ufr,
+ ufr: ufr,
+ Ugrave: Ugrave$1,
+ ugrave: ugrave$1,
+ uHar: uHar,
+ uharl: uharl,
+ uharr: uharr,
+ uhblk: uhblk,
+ ulcorn: ulcorn,
+ ulcorner: ulcorner,
+ ulcrop: ulcrop,
+ ultri: ultri,
+ Umacr: Umacr,
+ umacr: umacr,
+ uml: uml$1,
+ UnderBar: UnderBar,
+ UnderBrace: UnderBrace,
+ UnderBracket: UnderBracket,
+ UnderParenthesis: UnderParenthesis,
+ Union: Union,
+ UnionPlus: UnionPlus,
+ Uogon: Uogon,
+ uogon: uogon,
+ Uopf: Uopf,
+ uopf: uopf,
+ UpArrowBar: UpArrowBar,
+ uparrow: uparrow,
+ UpArrow: UpArrow,
+ Uparrow: Uparrow,
+ UpArrowDownArrow: UpArrowDownArrow,
+ updownarrow: updownarrow,
+ UpDownArrow: UpDownArrow,
+ Updownarrow: Updownarrow,
+ UpEquilibrium: UpEquilibrium,
+ upharpoonleft: upharpoonleft,
+ upharpoonright: upharpoonright,
+ uplus: uplus,
+ UpperLeftArrow: UpperLeftArrow,
+ UpperRightArrow: UpperRightArrow,
+ upsi: upsi,
+ Upsi: Upsi,
+ upsih: upsih,
+ Upsilon: Upsilon,
+ upsilon: upsilon,
+ UpTeeArrow: UpTeeArrow,
+ UpTee: UpTee,
+ upuparrows: upuparrows,
+ urcorn: urcorn,
+ urcorner: urcorner,
+ urcrop: urcrop,
+ Uring: Uring,
+ uring: uring,
+ urtri: urtri,
+ Uscr: Uscr,
+ uscr: uscr,
+ utdot: utdot,
+ Utilde: Utilde,
+ utilde: utilde,
+ utri: utri,
+ utrif: utrif,
+ uuarr: uuarr,
+ Uuml: Uuml$1,
+ uuml: uuml$1,
+ uwangle: uwangle,
+ vangrt: vangrt,
+ varepsilon: varepsilon,
+ varkappa: varkappa,
+ varnothing: varnothing,
+ varphi: varphi,
+ varpi: varpi,
+ varpropto: varpropto,
+ varr: varr,
+ vArr: vArr,
+ varrho: varrho,
+ varsigma: varsigma,
+ varsubsetneq: varsubsetneq,
+ varsubsetneqq: varsubsetneqq,
+ varsupsetneq: varsupsetneq,
+ varsupsetneqq: varsupsetneqq,
+ vartheta: vartheta,
+ vartriangleleft: vartriangleleft,
+ vartriangleright: vartriangleright,
+ vBar: vBar,
+ Vbar: Vbar,
+ vBarv: vBarv,
+ Vcy: Vcy,
+ vcy: vcy,
+ vdash: vdash,
+ vDash: vDash,
+ Vdash: Vdash,
+ VDash: VDash,
+ Vdashl: Vdashl,
+ veebar: veebar,
+ vee: vee,
+ Vee: Vee,
+ veeeq: veeeq,
+ vellip: vellip,
+ verbar: verbar,
+ Verbar: Verbar,
+ vert: vert,
+ Vert: Vert,
+ VerticalBar: VerticalBar,
+ VerticalLine: VerticalLine,
+ VerticalSeparator: VerticalSeparator,
+ VerticalTilde: VerticalTilde,
+ VeryThinSpace: VeryThinSpace,
+ Vfr: Vfr,
+ vfr: vfr,
+ vltri: vltri,
+ vnsub: vnsub,
+ vnsup: vnsup,
+ Vopf: Vopf,
+ vopf: vopf,
+ vprop: vprop,
+ vrtri: vrtri,
+ Vscr: Vscr,
+ vscr: vscr,
+ vsubnE: vsubnE,
+ vsubne: vsubne,
+ vsupnE: vsupnE,
+ vsupne: vsupne,
+ Vvdash: Vvdash,
+ vzigzag: vzigzag,
+ Wcirc: Wcirc,
+ wcirc: wcirc,
+ wedbar: wedbar,
+ wedge: wedge,
+ Wedge: Wedge,
+ wedgeq: wedgeq,
+ weierp: weierp,
+ Wfr: Wfr,
+ wfr: wfr,
+ Wopf: Wopf,
+ wopf: wopf,
+ wp: wp,
+ wr: wr,
+ wreath: wreath,
+ Wscr: Wscr,
+ wscr: wscr,
+ xcap: xcap,
+ xcirc: xcirc,
+ xcup: xcup,
+ xdtri: xdtri,
+ Xfr: Xfr,
+ xfr: xfr,
+ xharr: xharr,
+ xhArr: xhArr,
+ Xi: Xi,
+ xi: xi,
+ xlarr: xlarr,
+ xlArr: xlArr,
+ xmap: xmap,
+ xnis: xnis,
+ xodot: xodot,
+ Xopf: Xopf,
+ xopf: xopf,
+ xoplus: xoplus,
+ xotime: xotime,
+ xrarr: xrarr,
+ xrArr: xrArr,
+ Xscr: Xscr,
+ xscr: xscr,
+ xsqcup: xsqcup,
+ xuplus: xuplus,
+ xutri: xutri,
+ xvee: xvee,
+ xwedge: xwedge,
+ Yacute: Yacute$1,
+ yacute: yacute$1,
+ YAcy: YAcy,
+ yacy: yacy,
+ Ycirc: Ycirc,
+ ycirc: ycirc,
+ Ycy: Ycy,
+ ycy: ycy,
+ yen: yen$1,
+ Yfr: Yfr,
+ yfr: yfr,
+ YIcy: YIcy,
+ yicy: yicy,
+ Yopf: Yopf,
+ yopf: yopf,
+ Yscr: Yscr,
+ yscr: yscr,
+ YUcy: YUcy,
+ yucy: yucy,
+ yuml: yuml$1,
+ Yuml: Yuml,
+ Zacute: Zacute,
+ zacute: zacute,
+ Zcaron: Zcaron,
+ zcaron: zcaron,
+ Zcy: Zcy,
+ zcy: zcy,
+ Zdot: Zdot,
+ zdot: zdot,
+ zeetrf: zeetrf,
+ ZeroWidthSpace: ZeroWidthSpace,
+ Zeta: Zeta,
+ zeta: zeta,
+ zfr: zfr,
+ Zfr: Zfr,
+ ZHcy: ZHcy,
+ zhcy: zhcy,
+ zigrarr: zigrarr,
+ zopf: zopf,
+ Zopf: Zopf,
+ Zscr: Zscr,
+ zscr: zscr,
+ zwj: zwj,
+ zwnj: zwnj
+};
+var Aacute = "Á";
+var aacute = "á";
+var Acirc = "Â";
+var acirc = "â";
+var acute = "´";
+var AElig = "Æ";
+var aelig = "æ";
+var Agrave = "À";
+var agrave = "à";
+var amp$1 = "&";
+var AMP = "&";
+var Aring = "Å";
+var aring = "å";
+var Atilde = "Ã";
+var atilde = "ã";
+var Auml = "Ä";
+var auml = "ä";
+var brvbar = "¦";
+var Ccedil = "Ç";
+var ccedil = "ç";
+var cedil = "¸";
+var cent = "¢";
+var esm_copy = "©";
+var COPY = "©";
+var curren = "¤";
+var deg = "°";
+var divide = "÷";
+var Eacute = "É";
+var eacute = "é";
+var Ecirc = "Ê";
+var ecirc = "ê";
+var Egrave = "È";
+var egrave = "è";
+var ETH = "Ð";
+var eth = "ð";
+var Euml = "Ë";
+var euml = "ë";
+var frac12 = "½";
+var frac14 = "¼";
+var frac34 = "¾";
+var gt$1 = ">";
+var GT = ">";
+var Iacute = "Í";
+var iacute = "í";
+var Icirc = "Î";
+var icirc = "î";
+var iexcl = "¡";
+var Igrave = "Ì";
+var igrave = "ì";
+var iquest = "¿";
+var Iuml = "Ï";
+var iuml = "ï";
+var laquo = "«";
+var lt$1 = "<";
+var LT = "<";
+var macr = "¯";
+var micro = "µ";
+var middot = "·";
+var nbsp = " ";
+var not = "¬";
+var Ntilde = "Ñ";
+var ntilde = "ñ";
+var Oacute = "Ó";
+var oacute = "ó";
+var Ocirc = "Ô";
+var ocirc = "ô";
+var Ograve = "Ò";
+var ograve = "ò";
+var ordf = "ª";
+var ordm = "º";
+var Oslash = "Ø";
+var oslash = "ø";
+var Otilde = "Õ";
+var otilde = "õ";
+var Ouml = "Ö";
+var ouml = "ö";
+var para = "¶";
+var plusmn = "±";
+var pound = "£";
+var quot$1 = "\"";
+var QUOT = "\"";
+var raquo = "»";
+var reg = "®";
+var REG = "®";
+var sect = "§";
+var shy = "";
+var sup1 = "¹";
+var sup2 = "²";
+var sup3 = "³";
+var szlig = "ß";
+var THORN = "Þ";
+var thorn = "þ";
+var times = "×";
+var Uacute = "Ú";
+var uacute = "ú";
+var Ucirc = "Û";
+var ucirc = "û";
+var Ugrave = "Ù";
+var ugrave = "ù";
+var uml = "¨";
+var Uuml = "Ü";
+var uuml = "ü";
+var Yacute = "Ý";
+var yacute = "ý";
+var yen = "¥";
+var yuml = "ÿ";
+var require$$1 = {
+ Aacute: Aacute,
+ aacute: aacute,
+ Acirc: Acirc,
+ acirc: acirc,
+ acute: acute,
+ AElig: AElig,
+ aelig: aelig,
+ Agrave: Agrave,
+ agrave: agrave,
+ amp: amp$1,
+ AMP: AMP,
+ Aring: Aring,
+ aring: aring,
+ Atilde: Atilde,
+ atilde: atilde,
+ Auml: Auml,
+ auml: auml,
+ brvbar: brvbar,
+ Ccedil: Ccedil,
+ ccedil: ccedil,
+ cedil: cedil,
+ cent: cent,
+ copy: esm_copy,
+ COPY: COPY,
+ curren: curren,
+ deg: deg,
+ divide: divide,
+ Eacute: Eacute,
+ eacute: eacute,
+ Ecirc: Ecirc,
+ ecirc: ecirc,
+ Egrave: Egrave,
+ egrave: egrave,
+ ETH: ETH,
+ eth: eth,
+ Euml: Euml,
+ euml: euml,
+ frac12: frac12,
+ frac14: frac14,
+ frac34: frac34,
+ gt: gt$1,
+ GT: GT,
+ Iacute: Iacute,
+ iacute: iacute,
+ Icirc: Icirc,
+ icirc: icirc,
+ iexcl: iexcl,
+ Igrave: Igrave,
+ igrave: igrave,
+ iquest: iquest,
+ Iuml: Iuml,
+ iuml: iuml,
+ laquo: laquo,
+ lt: lt$1,
+ LT: LT,
+ macr: macr,
+ micro: micro,
+ middot: middot,
+ nbsp: nbsp,
+ not: not,
+ Ntilde: Ntilde,
+ ntilde: ntilde,
+ Oacute: Oacute,
+ oacute: oacute,
+ Ocirc: Ocirc,
+ ocirc: ocirc,
+ Ograve: Ograve,
+ ograve: ograve,
+ ordf: ordf,
+ ordm: ordm,
+ Oslash: Oslash,
+ oslash: oslash,
+ Otilde: Otilde,
+ otilde: otilde,
+ Ouml: Ouml,
+ ouml: ouml,
+ para: para,
+ plusmn: plusmn,
+ pound: pound,
+ quot: quot$1,
+ QUOT: QUOT,
+ raquo: raquo,
+ reg: reg,
+ REG: REG,
+ sect: sect,
+ shy: shy,
+ sup1: sup1,
+ sup2: sup2,
+ sup3: sup3,
+ szlig: szlig,
+ THORN: THORN,
+ thorn: thorn,
+ times: times,
+ Uacute: Uacute,
+ uacute: uacute,
+ Ucirc: Ucirc,
+ ucirc: ucirc,
+ Ugrave: Ugrave,
+ ugrave: ugrave,
+ uml: uml,
+ Uuml: Uuml,
+ uuml: uuml,
+ Yacute: Yacute,
+ yacute: yacute,
+ yen: yen,
+ yuml: yuml
+};
+var amp = "&";
+var apos = "'";
+var gt = ">";
+var lt = "<";
+var quot = "\"";
+var require$$0$1 = {
+ amp: amp,
+ apos: apos,
+ gt: gt,
+ lt: lt,
+ quot: quot
+};
+var decode_codepoint = {};
+var require$$0 = {
+ "0": 65533,
+ "128": 8364,
+ "130": 8218,
+ "131": 402,
+ "132": 8222,
+ "133": 8230,
+ "134": 8224,
+ "135": 8225,
+ "136": 710,
+ "137": 8240,
+ "138": 352,
+ "139": 8249,
+ "140": 338,
+ "142": 381,
+ "145": 8216,
+ "146": 8217,
+ "147": 8220,
+ "148": 8221,
+ "149": 8226,
+ "150": 8211,
+ "151": 8212,
+ "152": 732,
+ "153": 8482,
+ "154": 353,
+ "155": 8250,
+ "156": 339,
+ "158": 382,
+ "159": 376
+};
+var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(decode_codepoint, "__esModule", { value: true });
+var decode_json_1 = __importDefault$2(require$$0);
+// Adapted from https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
+var fromCodePoint$2 =
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+String.fromCodePoint ||
+ function (codePoint) {
+ var output = "";
+ if (codePoint > 0xffff) {
+ codePoint -= 0x10000;
+ output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
+ codePoint = 0xdc00 | (codePoint & 0x3ff);
+ }
+ output += String.fromCharCode(codePoint);
+ return output;
+ };
+function decodeCodePoint(codePoint) {
+ if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+ return "\uFFFD";
+ }
+ if (codePoint in decode_json_1.default) {
+ codePoint = decode_json_1.default[codePoint];
+ }
+ return fromCodePoint$2(codePoint);
+}
+decode_codepoint.default = decodeCodePoint;
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(decode, "__esModule", { value: true });
+decode.decodeHTML = decode.decodeHTMLStrict = decode.decodeXML = void 0;
+var entities_json_1$1 = __importDefault$1(require$$1$1);
+var legacy_json_1 = __importDefault$1(require$$1);
+var xml_json_1$1 = __importDefault$1(require$$0$1);
+var decode_codepoint_1 = __importDefault$1(decode_codepoint);
+var strictEntityRe = /&(?:[a-zA-Z0-9]+|#[xX][\da-fA-F]+|#\d+);/g;
+decode.decodeXML = getStrictDecoder(xml_json_1$1.default);
+decode.decodeHTMLStrict = getStrictDecoder(entities_json_1$1.default);
+function getStrictDecoder(map) {
+ var replace = getReplacer(map);
+ return function (str) { return String(str).replace(strictEntityRe, replace); };
+}
+var sorter = function (a, b) { return (a < b ? 1 : -1); };
+decode.decodeHTML = (function () {
+ var legacy = Object.keys(legacy_json_1.default).sort(sorter);
+ var keys = Object.keys(entities_json_1$1.default).sort(sorter);
+ for (var i = 0, j = 0; i < keys.length; i++) {
+ if (legacy[j] === keys[i]) {
+ keys[i] += ";?";
+ j++;
+ }
+ else {
+ keys[i] += ";";
+ }
+ }
+ var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g");
+ var replace = getReplacer(entities_json_1$1.default);
+ function replacer(str) {
+ if (str.substr(-1) !== ";")
+ str += ";";
+ return replace(str);
+ }
+ // TODO consider creating a merged map
+ return function (str) { return String(str).replace(re, replacer); };
+})();
+function getReplacer(map) {
+ return function replace(str) {
+ if (str.charAt(1) === "#") {
+ var secondChar = str.charAt(2);
+ if (secondChar === "X" || secondChar === "x") {
+ return decode_codepoint_1.default(parseInt(str.substr(3), 16));
+ }
+ return decode_codepoint_1.default(parseInt(str.substr(2), 10));
+ }
+ // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+ return map[str.slice(1, -1)] || str;
+ };
+}
+var encode = {};
+var esm_importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(encode, "__esModule", { value: true });
+encode.escapeUTF8 = encode.escape = encode.encodeNonAsciiHTML = encode.encodeHTML = encode.encodeXML = void 0;
+var xml_json_1 = esm_importDefault(require$$0$1);
+var inverseXML = getInverseObj(xml_json_1.default);
+var xmlReplacer = getInverseReplacer(inverseXML);
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using XML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+encode.encodeXML = getASCIIEncoder(inverseXML);
+var entities_json_1 = esm_importDefault(require$$1$1);
+var inverseHTML = getInverseObj(entities_json_1.default);
+var htmlReplacer = getInverseReplacer(inverseHTML);
+/**
+ * Encodes all entities and non-ASCII characters in the input.
+ *
+ * This includes characters that are valid ASCII characters in HTML documents.
+ * For example `#` will be encoded as `#`. To get a more compact output,
+ * consider using the `encodeNonAsciiHTML` function.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+encode.encodeHTML = getInverse(inverseHTML, htmlReplacer);
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in HTML
+ * documents using HTML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+encode.encodeNonAsciiHTML = getASCIIEncoder(inverseHTML);
+function getInverseObj(obj) {
+ return Object.keys(obj)
+ .sort()
+ .reduce(function (inverse, name) {
+ inverse[obj[name]] = "&" + name + ";";
+ return inverse;
+ }, {});
+}
+function getInverseReplacer(inverse) {
+ var single = [];
+ var multiple = [];
+ for (var _i = 0, _a = Object.keys(inverse); _i < _a.length; _i++) {
+ var k = _a[_i];
+ if (k.length === 1) {
+ // Add value to single array
+ single.push("\\" + k);
+ }
+ else {
+ // Add value to multiple array
+ multiple.push(k);
+ }
+ }
+ // Add ranges to single characters.
+ single.sort();
+ for (var start = 0; start < single.length - 1; start++) {
+ // Find the end of a run of characters
+ var end = start;
+ while (end < single.length - 1 &&
+ single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {
+ end += 1;
+ }
+ var count = 1 + end - start;
+ // We want to replace at least three characters
+ if (count < 3)
+ continue;
+ single.splice(start, count, single[start] + "-" + single[end]);
+ }
+ multiple.unshift("[" + single.join("") + "]");
+ return new RegExp(multiple.join("|"), "g");
+}
+// /[^\0-\x7F]/gu
+var reNonASCII = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g;
+var getCodePoint =
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+String.prototype.codePointAt != null
+ ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+ function (str) { return str.codePointAt(0); }
+ : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ function (c) {
+ return (c.charCodeAt(0) - 0xd800) * 0x400 +
+ c.charCodeAt(1) -
+ 0xdc00 +
+ 0x10000;
+ };
+function singleCharReplacer(c) {
+ return "&#x" + (c.length > 1 ? getCodePoint(c) : c.charCodeAt(0))
+ .toString(16)
+ .toUpperCase() + ";";
+}
+function getInverse(inverse, re) {
+ return function (data) {
+ return data
+ .replace(re, function (name) { return inverse[name]; })
+ .replace(reNonASCII, singleCharReplacer);
+ };
+}
+var esm_reEscapeChars = new RegExp(xmlReplacer.source + "|" + reNonASCII.source, "g");
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using numeric hexadecimal reference (eg. `ü`).
+ *
+ * Have a look at `escapeUTF8` if you want a more concise output at the expense
+ * of reduced transportability.
+ *
+ * @param data String to escape.
+ */
+function esm_escape(data) {
+ return data.replace(esm_reEscapeChars, singleCharReplacer);
+}
+encode.escape = esm_escape;
+/**
+ * Encodes all characters not valid in XML documents using numeric hexadecimal
+ * reference (eg. `ü`).
+ *
+ * Note that the output will be character-set dependent.
+ *
+ * @param data String to escape.
+ */
+function escapeUTF8(data) {
+ return data.replace(xmlReplacer, singleCharReplacer);
+}
+encode.escapeUTF8 = escapeUTF8;
+function getASCIIEncoder(obj) {
+ return function (data) {
+ return data.replace(esm_reEscapeChars, function (c) { return obj[c] || singleCharReplacer(c); });
+ };
+}
+(function (exports) {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = void 0;
+ var decode_1 = decode;
+ var encode_1 = encode;
+ /**
+ * Decodes a string with entities.
+ *
+ * @param data String to decode.
+ * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.
+ * @deprecated Use `decodeXML` or `decodeHTML` directly.
+ */
+ function decode$1(data, level) {
+ return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);
+ }
+ exports.decode = decode$1;
+ /**
+ * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
+ *
+ * @param data String to decode.
+ * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.
+ * @deprecated Use `decodeHTMLStrict` or `decodeXML` directly.
+ */
+ function decodeStrict(data, level) {
+ return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);
+ }
+ exports.decodeStrict = decodeStrict;
+ /**
+ * Encodes a string with entities.
+ *
+ * @param data String to encode.
+ * @param level Optional level to encode at. 0 = XML, 1 = HTML. Default is 0.
+ * @deprecated Use `encodeHTML`, `encodeXML` or `encodeNonAsciiHTML` directly.
+ */
+ function encode$1(data, level) {
+ return (!level || level <= 0 ? encode_1.encodeXML : encode_1.encodeHTML)(data);
+ }
+ exports.encode = encode$1;
+ var encode_2 = encode;
+ Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function () { return encode_2.encodeXML; } });
+ Object.defineProperty(exports, "encodeHTML", { enumerable: true, get: function () { return encode_2.encodeHTML; } });
+ Object.defineProperty(exports, "encodeNonAsciiHTML", { enumerable: true, get: function () { return encode_2.encodeNonAsciiHTML; } });
+ Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return encode_2.escape; } });
+ Object.defineProperty(exports, "escapeUTF8", { enumerable: true, get: function () { return encode_2.escapeUTF8; } });
+ // Legacy aliases (deprecated)
+ Object.defineProperty(exports, "encodeHTML4", { enumerable: true, get: function () { return encode_2.encodeHTML; } });
+ Object.defineProperty(exports, "encodeHTML5", { enumerable: true, get: function () { return encode_2.encodeHTML; } });
+ var decode_2 = decode;
+ Object.defineProperty(exports, "decodeXML", { enumerable: true, get: function () { return decode_2.decodeXML; } });
+ Object.defineProperty(exports, "decodeHTML", { enumerable: true, get: function () { return decode_2.decodeHTML; } });
+ Object.defineProperty(exports, "decodeHTMLStrict", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });
+ // Legacy aliases (deprecated)
+ Object.defineProperty(exports, "decodeHTML4", { enumerable: true, get: function () { return decode_2.decodeHTML; } });
+ Object.defineProperty(exports, "decodeHTML5", { enumerable: true, get: function () { return decode_2.decodeHTML; } });
+ Object.defineProperty(exports, "decodeHTML4Strict", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });
+ Object.defineProperty(exports, "decodeHTML5Strict", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });
+ Object.defineProperty(exports, "decodeXMLStrict", { enumerable: true, get: function () { return decode_2.decodeXML; } });
+}(lib));
+var ENTITY = '&(?:#x[a-f0-9]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});';
+var C_BACKSLASH$1 = 92;
+var reBackslashOrAmp = /[\\&]/;
+var ESCAPABLE = '[!"#$%&\'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]';
+var reEntityOrEscapedChar = new RegExp("\\\\" + ESCAPABLE + "|" + ENTITY, 'gi');
+var esm_XMLSPECIAL = '[&<>"]';
+var esm_reXmlSpecial = new RegExp(esm_XMLSPECIAL, 'g');
+var unescapeChar = function (s) {
+ if (s.charCodeAt(0) === C_BACKSLASH$1) {
+ return s.charAt(1);
+ }
+ return lib.decodeHTML(s);
+};
+// Replace entities and backslash escapes with literal characters.
+function unescapeString(s) {
+ if (reBackslashOrAmp.test(s)) {
+ return s.replace(reEntityOrEscapedChar, unescapeChar);
+ }
+ return s;
+}
+function normalizeURI(uri) {
+ try {
+ return encode_1(uri);
+ }
+ catch (err) {
+ return uri;
+ }
+}
+function esm_replaceUnsafeChar(s) {
+ switch (s) {
+ case '&':
+ return '&';
+ case '<':
+ return '<';
+ case '>':
+ return '>';
+ case '"':
+ return '"';
+ default:
+ return s;
+ }
+}
+function esm_escapeXml(s) {
+ if (esm_reXmlSpecial.test(s)) {
+ return s.replace(esm_reXmlSpecial, esm_replaceUnsafeChar);
+ }
+ return s;
+}
+function esm_repeat(str, count) {
+ var arr = [];
+ for (var i = 0; i < count; i++) {
+ arr.push(str);
+ }
+ return arr.join('');
+}
+function isEmpty(str) {
+ if (!str) {
+ return true;
+ }
+ return !/[^ \t]+/.test(str);
+}
+var NodeWalker = /** @class */ (function () {
+ function NodeWalker(root) {
+ this.current = root;
+ this.root = root;
+ this.entering = true;
+ }
+ NodeWalker.prototype.next = function () {
+ var cur = this.current;
+ var entering = this.entering;
+ if (cur === null) {
+ return null;
+ }
+ var container = esm_isContainer(cur);
+ if (entering && container) {
+ if (cur.firstChild) {
+ this.current = cur.firstChild;
+ this.entering = true;
+ }
+ else {
+ // stay on node but exit
+ this.entering = false;
+ }
+ }
+ else if (cur === this.root) {
+ this.current = null;
+ }
+ else if (cur.next === null) {
+ this.current = cur.parent;
+ this.entering = false;
+ }
+ else {
+ this.current = cur.next;
+ this.entering = true;
+ }
+ return { entering: entering, node: cur };
+ };
+ NodeWalker.prototype.resumeAt = function (node, entering) {
+ this.current = node;
+ this.entering = entering === true;
+ };
+ return NodeWalker;
+}());
+function esm_isContainer(node) {
+ switch (node.type) {
+ case 'document':
+ case 'blockQuote':
+ case 'list':
+ case 'item':
+ case 'paragraph':
+ case 'heading':
+ case 'emph':
+ case 'strong':
+ case 'strike':
+ case 'link':
+ case 'image':
+ case 'table':
+ case 'tableHead':
+ case 'tableBody':
+ case 'tableRow':
+ case 'tableCell':
+ case 'tableDelimRow':
+ case 'customInline':
+ return true;
+ default:
+ return false;
+ }
+}
+var lastNodeId = 1;
+var nodeMap = {};
+function getNodeById(id) {
+ return nodeMap[id];
+}
+function removeNodeById(id) {
+ delete nodeMap[id];
+}
+function removeAllNode() {
+ nodeMap = {};
+}
+var esm_Node = /** @class */ (function () {
+ function Node(nodeType, sourcepos) {
+ this.parent = null;
+ this.prev = null;
+ this.next = null;
+ // only for container node
+ this.firstChild = null;
+ this.lastChild = null;
+ // only for leaf node
+ this.literal = null;
+ if (nodeType === 'document') {
+ this.id = -1;
+ }
+ else {
+ this.id = lastNodeId++;
+ }
+ this.type = nodeType;
+ this.sourcepos = sourcepos;
+ nodeMap[this.id] = this;
+ }
+ Node.prototype.isContainer = function () {
+ return esm_isContainer(this);
+ };
+ Node.prototype.unlink = function () {
+ if (this.prev) {
+ this.prev.next = this.next;
+ }
+ else if (this.parent) {
+ this.parent.firstChild = this.next;
+ }
+ if (this.next) {
+ this.next.prev = this.prev;
+ }
+ else if (this.parent) {
+ this.parent.lastChild = this.prev;
+ }
+ this.parent = null;
+ this.next = null;
+ this.prev = null;
+ };
+ Node.prototype.replaceWith = function (node) {
+ this.insertBefore(node);
+ this.unlink();
+ };
+ Node.prototype.insertAfter = function (sibling) {
+ sibling.unlink();
+ sibling.next = this.next;
+ if (sibling.next) {
+ sibling.next.prev = sibling;
+ }
+ sibling.prev = this;
+ this.next = sibling;
+ if (this.parent) {
+ sibling.parent = this.parent;
+ if (!sibling.next) {
+ sibling.parent.lastChild = sibling;
+ }
+ }
+ };
+ Node.prototype.insertBefore = function (sibling) {
+ sibling.unlink();
+ sibling.prev = this.prev;
+ if (sibling.prev) {
+ sibling.prev.next = sibling;
+ }
+ sibling.next = this;
+ this.prev = sibling;
+ sibling.parent = this.parent;
+ if (!sibling.prev) {
+ sibling.parent.firstChild = sibling;
+ }
+ };
+ Node.prototype.appendChild = function (child) {
+ child.unlink();
+ child.parent = this;
+ if (this.lastChild) {
+ this.lastChild.next = child;
+ child.prev = this.lastChild;
+ this.lastChild = child;
+ }
+ else {
+ this.firstChild = child;
+ this.lastChild = child;
+ }
+ };
+ Node.prototype.prependChild = function (child) {
+ child.unlink();
+ child.parent = this;
+ if (this.firstChild) {
+ this.firstChild.prev = child;
+ child.next = this.firstChild;
+ this.firstChild = child;
+ }
+ else {
+ this.firstChild = child;
+ this.lastChild = child;
+ }
+ };
+ Node.prototype.walker = function () {
+ return new NodeWalker(this);
+ };
+ return Node;
+}());
+var BlockNode = /** @class */ (function (_super) {
+ esm_extends(BlockNode, _super);
+ function BlockNode(nodeType, sourcepos) {
+ var _this = _super.call(this, nodeType, sourcepos) || this;
+ // temporal data (for parsing)
+ _this.open = true;
+ _this.lineOffsets = null;
+ _this.stringContent = null;
+ _this.lastLineBlank = false;
+ _this.lastLineChecked = false;
+ _this.type = nodeType;
+ return _this;
+ }
+ return BlockNode;
+}(esm_Node));
+var ListNode = /** @class */ (function (_super) {
+ esm_extends(ListNode, _super);
+ function ListNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.listData = null;
+ return _this;
+ }
+ return ListNode;
+}(BlockNode));
+var HeadingNode = /** @class */ (function (_super) {
+ esm_extends(HeadingNode, _super);
+ function HeadingNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.level = 0;
+ _this.headingType = 'atx';
+ return _this;
+ }
+ return HeadingNode;
+}(BlockNode));
+var CodeBlockNode = /** @class */ (function (_super) {
+ esm_extends(CodeBlockNode, _super);
+ function CodeBlockNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.isFenced = false;
+ _this.fenceChar = null;
+ _this.fenceLength = 0;
+ _this.fenceOffset = -1;
+ _this.info = null;
+ _this.infoPadding = 0;
+ return _this;
+ }
+ return CodeBlockNode;
+}(BlockNode));
+var TableNode = /** @class */ (function (_super) {
+ esm_extends(TableNode, _super);
+ function TableNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.columns = [];
+ return _this;
+ }
+ return TableNode;
+}(BlockNode));
+var TableCellNode = /** @class */ (function (_super) {
+ esm_extends(TableCellNode, _super);
+ function TableCellNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.startIdx = 0;
+ _this.endIdx = 0;
+ _this.paddingLeft = 0;
+ _this.paddingRight = 0;
+ _this.ignored = false;
+ return _this;
+ }
+ return TableCellNode;
+}(BlockNode));
+var RefDefNode = /** @class */ (function (_super) {
+ esm_extends(RefDefNode, _super);
+ function RefDefNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.title = '';
+ _this.dest = '';
+ _this.label = '';
+ return _this;
+ }
+ return RefDefNode;
+}(BlockNode));
+var CustomBlockNode = /** @class */ (function (_super) {
+ esm_extends(CustomBlockNode, _super);
+ function CustomBlockNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.syntaxLength = 0;
+ _this.offset = -1;
+ _this.info = '';
+ return _this;
+ }
+ return CustomBlockNode;
+}(BlockNode));
+var HtmlBlockNode = /** @class */ (function (_super) {
+ esm_extends(HtmlBlockNode, _super);
+ function HtmlBlockNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.htmlBlockType = -1;
+ return _this;
+ }
+ return HtmlBlockNode;
+}(BlockNode));
+var LinkNode = /** @class */ (function (_super) {
+ esm_extends(LinkNode, _super);
+ function LinkNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.destination = null;
+ _this.title = null;
+ _this.extendedAutolink = false;
+ return _this;
+ }
+ return LinkNode;
+}(esm_Node));
+var CodeNode = /** @class */ (function (_super) {
+ esm_extends(CodeNode, _super);
+ function CodeNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.tickCount = 0;
+ return _this;
+ }
+ return CodeNode;
+}(esm_Node));
+var CustomInlineNode = /** @class */ (function (_super) {
+ esm_extends(CustomInlineNode, _super);
+ function CustomInlineNode() {
+ var _this = _super !== null && _super.apply(this, arguments) || this;
+ _this.info = '';
+ return _this;
+ }
+ return CustomInlineNode;
+}(esm_Node));
+function createNode(type, sourcepos) {
+ switch (type) {
+ case 'heading':
+ return new HeadingNode(type, sourcepos);
+ case 'list':
+ case 'item':
+ return new ListNode(type, sourcepos);
+ case 'link':
+ case 'image':
+ return new LinkNode(type, sourcepos);
+ case 'codeBlock':
+ return new CodeBlockNode(type, sourcepos);
+ case 'htmlBlock':
+ return new HtmlBlockNode(type, sourcepos);
+ case 'table':
+ return new TableNode(type, sourcepos);
+ case 'tableCell':
+ return new TableCellNode(type, sourcepos);
+ case 'document':
+ case 'paragraph':
+ case 'blockQuote':
+ case 'thematicBreak':
+ case 'tableRow':
+ case 'tableBody':
+ case 'tableHead':
+ case 'frontMatter':
+ return new BlockNode(type, sourcepos);
+ case 'code':
+ return new CodeNode(type, sourcepos);
+ case 'refDef':
+ return new RefDefNode(type, sourcepos);
+ case 'customBlock':
+ return new CustomBlockNode(type, sourcepos);
+ case 'customInline':
+ return new CustomInlineNode(type, sourcepos);
+ default:
+ return new esm_Node(type, sourcepos);
+ }
+}
+function isCodeBlock(node) {
+ return node.type === 'codeBlock';
+}
+function isHtmlBlock(node) {
+ return node.type === 'htmlBlock';
+}
+function isHeading(node) {
+ return node.type === 'heading';
+}
+function isList(node) {
+ return node.type === 'list';
+}
+function isTable(node) {
+ return node.type === 'table';
+}
+function isRefDef(node) {
+ return node.type === 'refDef';
+}
+function isCustomBlock(node) {
+ return node.type === 'customBlock';
+}
+function isCustomInline(node) {
+ return node.type === 'customInline';
+}
+function esm_text(s, sourcepos) {
+ var node = createNode('text', sourcepos);
+ node.literal = s;
+ return node;
+}
+var TAGNAME = '[A-Za-z][A-Za-z0-9-]*';
+var ATTRIBUTENAME = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
+var UNQUOTEDVALUE = '[^"\'=<>`\\x00-\\x20]+';
+var SINGLEQUOTEDVALUE = "'[^']*'";
+var DOUBLEQUOTEDVALUE = '"[^"]*"';
+var ATTRIBUTEVALUE = "(?:" + UNQUOTEDVALUE + "|" + SINGLEQUOTEDVALUE + "|" + DOUBLEQUOTEDVALUE + ")";
+var ATTRIBUTEVALUESPEC = "" + '(?:\\s*=\\s*' + ATTRIBUTEVALUE + ")";
+var esm_ATTRIBUTE = "" + '(?:\\s+' + ATTRIBUTENAME + ATTRIBUTEVALUESPEC + "?)";
+var OPENTAG = "<" + TAGNAME + esm_ATTRIBUTE + "*\\s*/?>";
+var CLOSETAG = "]";
+var HTMLCOMMENT = '|';
+var PROCESSINGINSTRUCTION = '[<][?].*?[?][>]';
+var DECLARATION = ']*>';
+var CDATA = '';
+var HTMLTAG = "(?:" + OPENTAG + "|" + CLOSETAG + "|" + HTMLCOMMENT + "|" + PROCESSINGINSTRUCTION + "|" + DECLARATION + "|" + CDATA + ")";
+var reHtmlTag = new RegExp("^" + HTMLTAG, 'i');
+// derived from https://github.com/mathiasbynens/String.fromCodePoint
+/*! http://mths.be/fromcodepoint v0.2.1 by @mathias */
+var fromCodePoint;
+if (String.fromCodePoint) {
+ fromCodePoint = function (_) {
+ try {
+ return String.fromCodePoint(_);
+ }
+ catch (e) {
+ if (e instanceof RangeError) {
+ return String.fromCharCode(0xfffd);
+ }
+ throw e;
+ }
+ };
+}
+else {
+ var stringFromCharCode_1 = String.fromCharCode;
+ var floor_1 = Math.floor;
+ fromCodePoint = function () {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var MAX_SIZE = 0x4000;
+ var codeUnits = [];
+ var highSurrogate;
+ var lowSurrogate;
+ var index = -1;
+ var length = args.length;
+ if (!length) {
+ return '';
+ }
+ var result = '';
+ while (++index < length) {
+ var codePoint = Number(args[index]);
+ if (!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+ codePoint < 0 || // not a valid Unicode code point
+ codePoint > 0x10ffff || // not a valid Unicode code point
+ floor_1(codePoint) !== codePoint // not an integer
+ ) {
+ return String.fromCharCode(0xfffd);
+ }
+ if (codePoint <= 0xffff) {
+ // BMP code point
+ codeUnits.push(codePoint);
+ }
+ else {
+ // Astral code point; split in surrogate halves
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ codePoint -= 0x10000;
+ highSurrogate = (codePoint >> 10) + 0xd800;
+ lowSurrogate = (codePoint % 0x400) + 0xdc00;
+ codeUnits.push(highSurrogate, lowSurrogate);
+ }
+ if (index + 1 === length || codeUnits.length > MAX_SIZE) {
+ result += stringFromCharCode_1.apply(void 0, codeUnits);
+ codeUnits.length = 0;
+ }
+ }
+ return result;
+ };
+}
+var fromCodePoint$1 = fromCodePoint;
+var DOMAIN = '(?:[w-]+.)*[A-Za-z0-9-]+.[A-Za-z0-9-]+';
+var PATH = '[^<\\s]*[^ lastIdx) {
+ newNodes.push(esm_text(literal.substring(lastIdx, range[0]), sourcepos(lastIdx, range[0] - 1)));
+ }
+ var linkNode = createNode('link', sourcepos.apply(void 0, range));
+ linkNode.appendChild(esm_text(linkText, sourcepos.apply(void 0, range)));
+ linkNode.destination = url;
+ linkNode.extendedAutolink = true;
+ newNodes.push(linkNode);
+ lastIdx = range[1] + 1;
+ }
+ if (lastIdx < literal.length) {
+ newNodes.push(esm_text(literal.substring(lastIdx), sourcepos(lastIdx, literal.length - 1)));
+ }
+ for (var _c = 0, newNodes_1 = newNodes; _c < newNodes_1.length; _c++) {
+ var newNode = newNodes_1[_c];
+ node.insertBefore(newNode);
+ }
+ node.unlink();
+ }
+ };
+ while ((event = walker.next())) {
+ _loop_1();
+ }
+}
+function esm_last(arr) {
+ return arr[arr.length - 1];
+}
+// normalize a reference in reference link (remove []s, trim,
+// collapse internal space, unicode case fold.
+// See commonmark/commonmark.js#168.
+function normalizeReference(str) {
+ return str
+ .slice(1, str.length - 1)
+ .trim()
+ .replace(/[ \t\r\n]+/, ' ')
+ .toLowerCase()
+ .toUpperCase();
+}
+function iterateObject(obj, iteratee) {
+ Object.keys(obj).forEach(function (key) {
+ iteratee(key, obj[key]);
+ });
+}
+function omit(obj) {
+ var propNames = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ propNames[_i - 1] = arguments[_i];
+ }
+ var resultMap = esm_assign({}, obj);
+ propNames.forEach(function (key) {
+ delete resultMap[key];
+ });
+ return resultMap;
+}
+function isEmptyObj(obj) {
+ return !Object.keys(obj).length;
+}
+function clearObj(obj) {
+ Object.keys(obj).forEach(function (key) {
+ delete obj[key];
+ });
+}
+var C_NEWLINE = 10;
+var C_ASTERISK = 42;
+var C_UNDERSCORE = 95;
+var C_BACKTICK = 96;
+var C_OPEN_BRACKET$1 = 91;
+var C_CLOSE_BRACKET = 93;
+var C_TILDE = 126;
+var C_LESSTHAN$1 = 60;
+var C_BANG = 33;
+var C_BACKSLASH = 92;
+var C_AMPERSAND = 38;
+var C_OPEN_PAREN = 40;
+var C_CLOSE_PAREN = 41;
+var C_COLON = 58;
+var C_SINGLEQUOTE = 39;
+var C_DOUBLEQUOTE = 34;
+var C_DOLLAR = 36;
+// Some regexps used in inline parser:
+var ESCAPED_CHAR = "\\\\" + ESCAPABLE;
+var rePunctuation = new RegExp(/[!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\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\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\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-\u2E42\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC9\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDF3C-\uDF3E]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]/);
+var reLinkTitle = new RegExp("^(?:\"(" + ESCAPED_CHAR + "|[^\"\\x00])*\"" +
+ "|" +
+ ("'(" + ESCAPED_CHAR + "|[^'\\x00])*'") +
+ "|" +
+ ("\\((" + ESCAPED_CHAR + "|[^()\\x00])*\\))"));
+var reLinkDestinationBraces = /^(?:<(?:[^<>\n\\\x00]|\\.)*>)/;
+var reEscapable = new RegExp("^" + ESCAPABLE);
+var reEntityHere = new RegExp("^" + ENTITY, 'i');
+var reTicks = /`+/;
+var reTicksHere = /^`+/;
+var reEllipses = /\.\.\./g;
+var reDash = /--+/g;
+var reEmailAutolink = /^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;
+var reAutolink = /^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*>/i;
+var reSpnl = /^ *(?:\n *)?/;
+var reWhitespaceChar = /^[ \t\n\x0b\x0c\x0d]/;
+var reUnicodeWhitespaceChar = /^\s/;
+var reFinalSpace = / *$/;
+var reInitialSpace = /^ */;
+var reSpaceAtEndOfLine = /^ *(?:\n|$)/;
+var reLinkLabel = /^\[(?:[^\\\[\]]|\\.){0,1000}\]/;
+// Matches a string of non-special characters.
+var reMain = /^[^\n`\[\]\\!<&*_'"~$]+/m;
+var InlineParser = /** @class */ (function () {
+ function InlineParser(options) {
+ // An InlineParser keeps track of a subject (a string to be parsed)
+ // and a position in that subject.
+ this.subject = '';
+ this.delimiters = null; // used by handleDelim method
+ this.brackets = null;
+ this.pos = 0;
+ this.lineStartNum = 0;
+ this.lineIdx = 0;
+ this.lineOffsets = [0];
+ this.linePosOffset = 0;
+ this.refMap = {};
+ this.refLinkCandidateMap = {};
+ this.refDefCandidateMap = {};
+ this.options = options;
+ }
+ InlineParser.prototype.sourcepos = function (start, end) {
+ var linePosOffset = this.linePosOffset + this.lineOffsets[this.lineIdx];
+ var lineNum = this.lineStartNum + this.lineIdx;
+ var startpos = [lineNum, start + linePosOffset];
+ if (typeof end === 'number') {
+ return [startpos, [lineNum, end + linePosOffset]];
+ }
+ return startpos;
+ };
+ InlineParser.prototype.nextLine = function () {
+ this.lineIdx += 1;
+ this.linePosOffset = -this.pos;
+ };
+ // If re matches at current position in the subject, advance
+ // position in subject and return the match; otherwise return null.
+ InlineParser.prototype.match = function (re) {
+ var m = re.exec(this.subject.slice(this.pos));
+ if (m === null) {
+ return null;
+ }
+ this.pos += m.index + m[0].length;
+ return m[0];
+ };
+ // Returns the code for the character at the current subject position, or -1
+ // there are no more characters.
+ InlineParser.prototype.peek = function () {
+ if (this.pos < this.subject.length) {
+ return this.subject.charCodeAt(this.pos);
+ }
+ return -1;
+ };
+ // Parse zero or more space characters, including at most one newline
+ InlineParser.prototype.spnl = function () {
+ this.match(reSpnl);
+ return true;
+ };
+ // All of the parsers below try to match something at the current position
+ // in the subject. If they succeed in matching anything, they
+ // return the inline matched, advancing the subject.
+ // Attempt to parse backticks, adding either a backtick code span or a
+ // literal sequence of backticks.
+ InlineParser.prototype.parseBackticks = function (block) {
+ var startpos = this.pos + 1;
+ var ticks = this.match(reTicksHere);
+ if (ticks === null) {
+ return false;
+ }
+ var afterOpenTicks = this.pos;
+ var matched;
+ while ((matched = this.match(reTicks)) !== null) {
+ if (matched === ticks) {
+ var contents = this.subject.slice(afterOpenTicks, this.pos - ticks.length);
+ var sourcepos = this.sourcepos(startpos, this.pos);
+ var lines = contents.split('\n');
+ if (lines.length > 1) {
+ var lastLine = esm_last(lines);
+ this.lineIdx += lines.length - 1;
+ this.linePosOffset = -(this.pos - lastLine.length - ticks.length);
+ sourcepos[1] = this.sourcepos(this.pos);
+ contents = lines.join(' ');
+ }
+ var node = createNode('code', sourcepos);
+ if (contents.length > 0 &&
+ contents.match(/[^ ]/) !== null &&
+ contents[0] == ' ' &&
+ contents[contents.length - 1] == ' ') {
+ node.literal = contents.slice(1, contents.length - 1);
+ }
+ else {
+ node.literal = contents;
+ }
+ node.tickCount = ticks.length;
+ block.appendChild(node);
+ return true;
+ }
+ }
+ // If we got here, we didn't match a closing backtick sequence.
+ this.pos = afterOpenTicks;
+ block.appendChild(esm_text(ticks, this.sourcepos(startpos, this.pos - 1)));
+ return true;
+ };
+ // Parse a backslash-escaped special character, adding either the escaped
+ // character, a hard line break (if the backslash is followed by a newline),
+ // or a literal backslash to the block's children. Assumes current character
+ // is a backslash.
+ InlineParser.prototype.parseBackslash = function (block) {
+ var subj = this.subject;
+ var node;
+ this.pos += 1;
+ var startpos = this.pos;
+ if (this.peek() === C_NEWLINE) {
+ this.pos += 1;
+ node = createNode('linebreak', this.sourcepos(this.pos - 1, this.pos));
+ block.appendChild(node);
+ this.nextLine();
+ }
+ else if (reEscapable.test(subj.charAt(this.pos))) {
+ block.appendChild(esm_text(subj.charAt(this.pos), this.sourcepos(startpos, this.pos)));
+ this.pos += 1;
+ }
+ else {
+ block.appendChild(esm_text('\\', this.sourcepos(startpos, startpos)));
+ }
+ return true;
+ };
+ // Attempt to parse an autolink (URL or email in pointy brackets).
+ InlineParser.prototype.parseAutolink = function (block) {
+ var m;
+ var dest;
+ var node;
+ var startpos = this.pos + 1;
+ if ((m = this.match(reEmailAutolink))) {
+ dest = m.slice(1, m.length - 1);
+ node = createNode('link', this.sourcepos(startpos, this.pos));
+ node.destination = normalizeURI("mailto:" + dest);
+ node.title = '';
+ node.appendChild(esm_text(dest, this.sourcepos(startpos + 1, this.pos - 1)));
+ block.appendChild(node);
+ return true;
+ }
+ if ((m = this.match(reAutolink))) {
+ dest = m.slice(1, m.length - 1);
+ node = createNode('link', this.sourcepos(startpos, this.pos));
+ node.destination = normalizeURI(dest);
+ node.title = '';
+ node.appendChild(esm_text(dest, this.sourcepos(startpos + 1, this.pos - 1)));
+ block.appendChild(node);
+ return true;
+ }
+ return false;
+ };
+ // Attempt to parse a raw HTML tag.
+ InlineParser.prototype.parseHtmlTag = function (block) {
+ var startpos = this.pos + 1;
+ var m = this.match(reHtmlTag);
+ if (m === null) {
+ return false;
+ }
+ var node = createNode('htmlInline', this.sourcepos(startpos, this.pos));
+ node.literal = m;
+ block.appendChild(node);
+ return true;
+ };
+ // Scan a sequence of characters with code cc, and return information about
+ // the number of delimiters and whether they are positioned such that
+ // they can open and/or close emphasis or strong emphasis. A utility
+ // function for strong/emph parsing.
+ InlineParser.prototype.scanDelims = function (cc) {
+ var numdelims = 0;
+ var startpos = this.pos;
+ if (cc === C_SINGLEQUOTE || cc === C_DOUBLEQUOTE) {
+ numdelims++;
+ this.pos++;
+ }
+ else {
+ while (this.peek() === cc) {
+ numdelims++;
+ this.pos++;
+ }
+ }
+ if (numdelims === 0 || (numdelims < 2 && (cc === C_TILDE || cc === C_DOLLAR))) {
+ this.pos = startpos;
+ return null;
+ }
+ var charBefore = startpos === 0 ? '\n' : this.subject.charAt(startpos - 1);
+ var ccAfter = this.peek();
+ var charAfter;
+ if (ccAfter === -1) {
+ charAfter = '\n';
+ }
+ else {
+ charAfter = fromCodePoint$1(ccAfter);
+ }
+ var afterIsWhitespace = reUnicodeWhitespaceChar.test(charAfter);
+ var afterIsPunctuation = rePunctuation.test(charAfter);
+ var beforeIsWhitespace = reUnicodeWhitespaceChar.test(charBefore);
+ var beforeIsPunctuation = rePunctuation.test(charBefore);
+ var leftFlanking = !afterIsWhitespace && (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+ var rightFlanking = !beforeIsWhitespace && (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+ var canOpen;
+ var canClose;
+ if (cc === C_UNDERSCORE) {
+ canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation);
+ canClose = rightFlanking && (!leftFlanking || afterIsPunctuation);
+ }
+ else if (cc === C_SINGLEQUOTE || cc === C_DOUBLEQUOTE) {
+ canOpen = leftFlanking && !rightFlanking;
+ canClose = rightFlanking;
+ }
+ else if (cc === C_DOLLAR) {
+ canOpen = !afterIsWhitespace;
+ canClose = !beforeIsWhitespace;
+ }
+ else {
+ canOpen = leftFlanking;
+ canClose = rightFlanking;
+ }
+ this.pos = startpos;
+ return { numdelims: numdelims, canOpen: canOpen, canClose: canClose };
+ };
+ // Handle a delimiter marker for emphasis or a quote.
+ InlineParser.prototype.handleDelim = function (cc, block) {
+ var res = this.scanDelims(cc);
+ if (!res) {
+ return false;
+ }
+ var numdelims = res.numdelims;
+ var startpos = this.pos + 1;
+ var contents;
+ this.pos += numdelims;
+ if (cc === C_SINGLEQUOTE) {
+ contents = '\u2019';
+ }
+ else if (cc === C_DOUBLEQUOTE) {
+ contents = '\u201C';
+ }
+ else {
+ contents = this.subject.slice(startpos - 1, this.pos);
+ }
+ var node = esm_text(contents, this.sourcepos(startpos, this.pos));
+ block.appendChild(node);
+ // Add entry to stack for this opener
+ if ((res.canOpen || res.canClose) &&
+ (this.options.smart || (cc !== C_SINGLEQUOTE && cc !== C_DOUBLEQUOTE))) {
+ this.delimiters = {
+ cc: cc,
+ numdelims: numdelims,
+ origdelims: numdelims,
+ node: node,
+ previous: this.delimiters,
+ next: null,
+ canOpen: res.canOpen,
+ canClose: res.canClose,
+ };
+ if (this.delimiters.previous) {
+ this.delimiters.previous.next = this.delimiters;
+ }
+ }
+ return true;
+ };
+ InlineParser.prototype.removeDelimiter = function (delim) {
+ if (delim.previous !== null) {
+ delim.previous.next = delim.next;
+ }
+ if (delim.next === null) {
+ // top of stack
+ this.delimiters = delim.previous;
+ }
+ else {
+ delim.next.previous = delim.previous;
+ }
+ };
+ InlineParser.prototype.removeDelimitersBetween = function (bottom, top) {
+ if (bottom.next !== top) {
+ bottom.next = top;
+ top.previous = bottom;
+ }
+ };
+ /**
+ * Process all delimiters - emphasis, strong emphasis, strikethrough(gfm)
+ * If the smart punctuation options is true,
+ * convert single/double quotes to corresponding unicode characters.
+ **/
+ InlineParser.prototype.processEmphasis = function (stackBottom) {
+ var _a;
+ var opener;
+ var closer;
+ var oldCloser;
+ var openerInl, closerInl;
+ var openerFound;
+ var oddMatch = false;
+ var openersBottom = (_a = {},
+ _a[C_UNDERSCORE] = [stackBottom, stackBottom, stackBottom],
+ _a[C_ASTERISK] = [stackBottom, stackBottom, stackBottom],
+ _a[C_SINGLEQUOTE] = [stackBottom],
+ _a[C_DOUBLEQUOTE] = [stackBottom],
+ _a[C_TILDE] = [stackBottom],
+ _a[C_DOLLAR] = [stackBottom],
+ _a);
+ // find first closer above stackBottom:
+ closer = this.delimiters;
+ while (closer !== null && closer.previous !== stackBottom) {
+ closer = closer.previous;
+ }
+ // move forward, looking for closers, and handling each
+ while (closer !== null) {
+ var closercc = closer.cc;
+ var closerEmph = closercc === C_UNDERSCORE || closercc === C_ASTERISK;
+ if (!closer.canClose) {
+ closer = closer.next;
+ }
+ else {
+ // found emphasis closer. now look back for first matching opener:
+ opener = closer.previous;
+ openerFound = false;
+ while (opener !== null &&
+ opener !== stackBottom &&
+ opener !== openersBottom[closercc][closerEmph ? closer.origdelims % 3 : 0]) {
+ oddMatch =
+ closerEmph &&
+ (closer.canOpen || opener.canClose) &&
+ closer.origdelims % 3 !== 0 &&
+ (opener.origdelims + closer.origdelims) % 3 === 0;
+ if (opener.cc === closer.cc && opener.canOpen && !oddMatch) {
+ openerFound = true;
+ break;
+ }
+ opener = opener.previous;
+ }
+ oldCloser = closer;
+ if (closerEmph || closercc === C_TILDE || closercc === C_DOLLAR) {
+ if (!openerFound) {
+ closer = closer.next;
+ }
+ else if (opener) {
+ // (null opener check for type narrowing)
+ // calculate actual number of delimiters used from closer
+ var useDelims = closer.numdelims >= 2 && opener.numdelims >= 2 ? 2 : 1;
+ var emptyDelims = closerEmph ? 0 : 1;
+ openerInl = opener.node;
+ closerInl = closer.node;
+ // build contents for new emph element
+ var nodeType = closerEmph
+ ? useDelims === 1
+ ? 'emph'
+ : 'strong'
+ : 'strike';
+ if (closercc === C_DOLLAR) {
+ nodeType = 'customInline';
+ }
+ var newNode = createNode(nodeType);
+ var openerEndPos = openerInl.sourcepos[1];
+ var closerStartPos = closerInl.sourcepos[0];
+ newNode.sourcepos = [
+ [openerEndPos[0], openerEndPos[1] - useDelims + 1],
+ [closerStartPos[0], closerStartPos[1] + useDelims - 1],
+ ];
+ openerInl.sourcepos[1][1] -= useDelims;
+ closerInl.sourcepos[0][1] += useDelims;
+ openerInl.literal = openerInl.literal.slice(useDelims);
+ closerInl.literal = closerInl.literal.slice(useDelims);
+ opener.numdelims -= useDelims;
+ closer.numdelims -= useDelims;
+ // remove used delimiters from stack elts and inlines
+ var tmp = openerInl.next;
+ var next = void 0;
+ while (tmp && tmp !== closerInl) {
+ next = tmp.next;
+ tmp.unlink();
+ newNode.appendChild(tmp);
+ tmp = next;
+ }
+ // build custom inline node
+ if (closercc === C_DOLLAR) {
+ var textNode = newNode.firstChild;
+ var literal = textNode.literal || '';
+ var info = literal.split(/\s/)[0];
+ newNode.info = info;
+ if (literal.length <= info.length) {
+ textNode.unlink();
+ }
+ else {
+ textNode.sourcepos[0][1] += info.length;
+ textNode.literal = literal.replace(info + " ", '');
+ }
+ }
+ openerInl.insertAfter(newNode);
+ // remove elts between opener and closer in delimiters stack
+ this.removeDelimitersBetween(opener, closer);
+ // if opener has 0 delims, remove it and the inline
+ // if opener has 1 delims and character is tilde, remove delimiter only
+ if (opener.numdelims <= emptyDelims) {
+ if (opener.numdelims === 0) {
+ openerInl.unlink();
+ }
+ this.removeDelimiter(opener);
+ }
+ // if closer has 0 delims, remove it and the inline
+ // if closer has 1 delims and character is tilde, remove delimiter only
+ if (closer.numdelims <= emptyDelims) {
+ if (closer.numdelims === 0) {
+ closerInl.unlink();
+ }
+ var tempstack = closer.next;
+ this.removeDelimiter(closer);
+ closer = tempstack;
+ }
+ }
+ }
+ else if (closercc === C_SINGLEQUOTE) {
+ closer.node.literal = '\u2019';
+ if (openerFound) {
+ opener.node.literal = '\u2018';
+ }
+ closer = closer.next;
+ }
+ else if (closercc === C_DOUBLEQUOTE) {
+ closer.node.literal = '\u201D';
+ if (openerFound) {
+ opener.node.literal = '\u201C';
+ }
+ closer = closer.next;
+ }
+ if (!openerFound) {
+ // Set lower bound for future searches for openers:
+ openersBottom[closercc][closerEmph ? oldCloser.origdelims % 3 : 0] = oldCloser.previous;
+ if (!oldCloser.canOpen) {
+ // We can remove a closer that can't be an opener,
+ // once we've seen there's no matching opener:
+ this.removeDelimiter(oldCloser);
+ }
+ }
+ }
+ }
+ // remove all delimiters
+ while (this.delimiters !== null && this.delimiters !== stackBottom) {
+ this.removeDelimiter(this.delimiters);
+ }
+ };
+ // Attempt to parse link title (sans quotes), returning the string
+ // or null if no match.
+ InlineParser.prototype.parseLinkTitle = function () {
+ var title = this.match(reLinkTitle);
+ if (title === null) {
+ return null;
+ }
+ // chop off quotes from title and unescape:
+ return unescapeString(title.substr(1, title.length - 2));
+ };
+ // Attempt to parse link destination, returning the string or null if no match.
+ InlineParser.prototype.parseLinkDestination = function () {
+ var res = this.match(reLinkDestinationBraces);
+ if (res === null) {
+ if (this.peek() === C_LESSTHAN$1) {
+ return null;
+ }
+ // @TODO handrolled parser; res should be null or the string
+ var savepos = this.pos;
+ var openparens = 0;
+ var c = void 0;
+ while ((c = this.peek()) !== -1) {
+ if (c === C_BACKSLASH && reEscapable.test(this.subject.charAt(this.pos + 1))) {
+ this.pos += 1;
+ if (this.peek() !== -1) {
+ this.pos += 1;
+ }
+ }
+ else if (c === C_OPEN_PAREN) {
+ this.pos += 1;
+ openparens += 1;
+ }
+ else if (c === C_CLOSE_PAREN) {
+ if (openparens < 1) {
+ break;
+ }
+ else {
+ this.pos += 1;
+ openparens -= 1;
+ }
+ }
+ else if (reWhitespaceChar.exec(fromCodePoint$1(c)) !== null) {
+ break;
+ }
+ else {
+ this.pos += 1;
+ }
+ }
+ if (this.pos === savepos && c !== C_CLOSE_PAREN) {
+ return null;
+ }
+ if (openparens !== 0) {
+ return null;
+ }
+ res = this.subject.substr(savepos, this.pos - savepos);
+ return normalizeURI(unescapeString(res));
+ } // chop off surrounding <..>:
+ return normalizeURI(unescapeString(res.substr(1, res.length - 2)));
+ };
+ // Attempt to parse a link label, returning number of characters parsed.
+ InlineParser.prototype.parseLinkLabel = function () {
+ var m = this.match(reLinkLabel);
+ if (m === null || m.length > 1001) {
+ return 0;
+ }
+ return m.length;
+ };
+ // Add open bracket to delimiter stack and add a text node to block's children.
+ InlineParser.prototype.parseOpenBracket = function (block) {
+ var startpos = this.pos;
+ this.pos += 1;
+ var node = esm_text('[', this.sourcepos(this.pos, this.pos));
+ block.appendChild(node);
+ // Add entry to stack for this opener
+ this.addBracket(node, startpos, false);
+ return true;
+ };
+ // IF next character is [, and ! delimiter to delimiter stack and
+ // add a text node to block's children. Otherwise just add a text node.
+ InlineParser.prototype.parseBang = function (block) {
+ var startpos = this.pos;
+ this.pos += 1;
+ if (this.peek() === C_OPEN_BRACKET$1) {
+ this.pos += 1;
+ var node = esm_text('![', this.sourcepos(this.pos - 1, this.pos));
+ block.appendChild(node);
+ // Add entry to stack for this opener
+ this.addBracket(node, startpos + 1, true);
+ }
+ else {
+ var node = esm_text('!', this.sourcepos(this.pos, this.pos));
+ block.appendChild(node);
+ }
+ return true;
+ };
+ // Try to match close bracket against an opening in the delimiter
+ // stack. Add either a link or image, or a plain [ character,
+ // to block's children. If there is a matching delimiter,
+ // remove it from the delimiter stack.
+ InlineParser.prototype.parseCloseBracket = function (block) {
+ var dest = null;
+ var title = null;
+ var matched = false;
+ this.pos += 1;
+ var startpos = this.pos;
+ // get last [ or ![
+ var opener = this.brackets;
+ if (opener === null) {
+ // no matched opener, just return a literal
+ block.appendChild(esm_text(']', this.sourcepos(startpos, startpos)));
+ return true;
+ }
+ if (!opener.active) {
+ // no matched opener, just return a literal
+ block.appendChild(esm_text(']', this.sourcepos(startpos, startpos)));
+ // take opener off brackets stack
+ this.removeBracket();
+ return true;
+ }
+ // If we got here, open is a potential opener
+ var isImage = opener.image;
+ // Check to see if we have a link/image
+ var savepos = this.pos;
+ // Inline link?
+ if (this.peek() === C_OPEN_PAREN) {
+ this.pos++;
+ if (this.spnl() &&
+ (dest = this.parseLinkDestination()) !== null &&
+ this.spnl() &&
+ // make sure there's a space before the title:
+ ((reWhitespaceChar.test(this.subject.charAt(this.pos - 1)) &&
+ (title = this.parseLinkTitle())) ||
+ true) &&
+ this.spnl() &&
+ this.peek() === C_CLOSE_PAREN) {
+ this.pos += 1;
+ matched = true;
+ }
+ else {
+ this.pos = savepos;
+ }
+ }
+ var refLabel = '';
+ if (!matched) {
+ // Next, see if there's a link label
+ var beforelabel = this.pos;
+ var n = this.parseLinkLabel();
+ if (n > 2) {
+ refLabel = this.subject.slice(beforelabel, beforelabel + n);
+ }
+ else if (!opener.bracketAfter) {
+ // Empty or missing second label means to use the first label as the reference.
+ // The reference must not contain a bracket. If we know there's a bracket, we don't even bother checking it.
+ refLabel = this.subject.slice(opener.index, startpos);
+ }
+ if (n === 0) {
+ // If shortcut reference link, rewind before spaces we skipped.
+ this.pos = savepos;
+ }
+ if (refLabel) {
+ refLabel = normalizeReference(refLabel);
+ // lookup rawlabel in refMap
+ var link = this.refMap[refLabel];
+ if (link) {
+ dest = link.destination;
+ title = link.title;
+ matched = true;
+ }
+ }
+ }
+ if (matched) {
+ var node = createNode(isImage ? 'image' : 'link');
+ node.destination = dest;
+ node.title = title || '';
+ node.sourcepos = [opener.startpos, this.sourcepos(this.pos)];
+ var tmp = opener.node.next;
+ var next = void 0;
+ while (tmp) {
+ next = tmp.next;
+ tmp.unlink();
+ node.appendChild(tmp);
+ tmp = next;
+ }
+ block.appendChild(node);
+ this.processEmphasis(opener.previousDelimiter);
+ this.removeBracket();
+ opener.node.unlink();
+ // We remove this bracket and processEmphasis will remove later delimiters.
+ // Now, for a link, we also deactivate earlier link openers.
+ // (no links in links)
+ if (!isImage) {
+ opener = this.brackets;
+ while (opener !== null) {
+ if (!opener.image) {
+ opener.active = false; // deactivate this opener
+ }
+ opener = opener.previous;
+ }
+ }
+ if (this.options.referenceDefinition) {
+ this.refLinkCandidateMap[block.id] = { node: block, refLabel: refLabel };
+ }
+ return true;
+ } // no match
+ this.removeBracket(); // remove this opener from stack
+ this.pos = startpos;
+ block.appendChild(esm_text(']', this.sourcepos(startpos, startpos)));
+ if (this.options.referenceDefinition) {
+ this.refLinkCandidateMap[block.id] = { node: block, refLabel: refLabel };
+ }
+ return true;
+ };
+ InlineParser.prototype.addBracket = function (node, index, image) {
+ if (this.brackets !== null) {
+ this.brackets.bracketAfter = true;
+ }
+ this.brackets = {
+ node: node,
+ startpos: this.sourcepos(index + (image ? 0 : 1)),
+ previous: this.brackets,
+ previousDelimiter: this.delimiters,
+ index: index,
+ image: image,
+ active: true,
+ };
+ };
+ InlineParser.prototype.removeBracket = function () {
+ if (this.brackets) {
+ this.brackets = this.brackets.previous;
+ }
+ };
+ // Attempt to parse an entity.
+ InlineParser.prototype.parseEntity = function (block) {
+ var m;
+ var startpos = this.pos + 1;
+ if ((m = this.match(reEntityHere))) {
+ block.appendChild(esm_text(lib.decodeHTML(m), this.sourcepos(startpos, this.pos)));
+ return true;
+ }
+ return false;
+ };
+ // Parse a run of ordinary characters, or a single character with
+ // a special meaning in markdown, as a plain string.
+ InlineParser.prototype.parseString = function (block) {
+ var m;
+ var startpos = this.pos + 1;
+ if ((m = this.match(reMain))) {
+ if (this.options.smart) {
+ var lit = m.replace(reEllipses, '\u2026').replace(reDash, function (chars) {
+ var enCount = 0;
+ var emCount = 0;
+ if (chars.length % 3 === 0) {
+ // If divisible by 3, use all em dashes
+ emCount = chars.length / 3;
+ }
+ else if (chars.length % 2 === 0) {
+ // If divisible by 2, use all en dashes
+ enCount = chars.length / 2;
+ }
+ else if (chars.length % 3 === 2) {
+ // If 2 extra dashes, use en dash for last 2; em dashes for rest
+ enCount = 1;
+ emCount = (chars.length - 2) / 3;
+ }
+ else {
+ // Use en dashes for last 4 hyphens; em dashes for rest
+ enCount = 2;
+ emCount = (chars.length - 4) / 3;
+ }
+ return esm_repeat('\u2014', emCount) + esm_repeat('\u2013', enCount);
+ });
+ block.appendChild(esm_text(lit, this.sourcepos(startpos, this.pos)));
+ }
+ else {
+ var node = esm_text(m, this.sourcepos(startpos, this.pos));
+ block.appendChild(node);
+ }
+ return true;
+ }
+ return false;
+ };
+ // Parse a newline. If it was preceded by two spaces, return a hard
+ // line break; otherwise a soft line break.
+ InlineParser.prototype.parseNewline = function (block) {
+ this.pos += 1; // assume we're at a \n
+ // check previous node for trailing spaces
+ var lastc = block.lastChild;
+ if (lastc && lastc.type === 'text' && lastc.literal[lastc.literal.length - 1] === ' ') {
+ var hardbreak = lastc.literal[lastc.literal.length - 2] === ' ';
+ var litLen = lastc.literal.length;
+ lastc.literal = lastc.literal.replace(reFinalSpace, '');
+ var finalSpaceLen = litLen - lastc.literal.length;
+ lastc.sourcepos[1][1] -= finalSpaceLen;
+ block.appendChild(createNode(hardbreak ? 'linebreak' : 'softbreak', this.sourcepos(this.pos - finalSpaceLen, this.pos)));
+ }
+ else {
+ block.appendChild(createNode('softbreak', this.sourcepos(this.pos, this.pos)));
+ }
+ this.nextLine();
+ this.match(reInitialSpace); // gobble leading spaces in next line
+ return true;
+ };
+ // Attempt to parse a link reference, modifying refmap.
+ InlineParser.prototype.parseReference = function (block, refMap) {
+ if (!this.options.referenceDefinition) {
+ return 0;
+ }
+ this.subject = block.stringContent;
+ this.pos = 0;
+ var title = null;
+ var startpos = this.pos;
+ // label:
+ var matchChars = this.parseLinkLabel();
+ if (matchChars === 0) {
+ return 0;
+ }
+ var rawlabel = this.subject.substr(0, matchChars);
+ // colon:
+ if (this.peek() === C_COLON) {
+ this.pos++;
+ }
+ else {
+ this.pos = startpos;
+ return 0;
+ }
+ // link url
+ this.spnl();
+ var dest = this.parseLinkDestination();
+ if (dest === null) {
+ this.pos = startpos;
+ return 0;
+ }
+ var beforetitle = this.pos;
+ this.spnl();
+ if (this.pos !== beforetitle) {
+ title = this.parseLinkTitle();
+ }
+ if (title === null) {
+ title = '';
+ // rewind before spaces
+ this.pos = beforetitle;
+ }
+ // make sure we're at line end:
+ var atLineEnd = true;
+ if (this.match(reSpaceAtEndOfLine) === null) {
+ if (title === '') {
+ atLineEnd = false;
+ }
+ else {
+ // the potential title we found is not at the line end,
+ // but it could still be a legal link reference if we
+ // discard the title
+ title = '';
+ // rewind before spaces
+ this.pos = beforetitle;
+ // and instead check if the link URL is at the line end
+ atLineEnd = this.match(reSpaceAtEndOfLine) !== null;
+ }
+ }
+ if (!atLineEnd) {
+ this.pos = startpos;
+ return 0;
+ }
+ var normalLabel = normalizeReference(rawlabel);
+ if (normalLabel === '') {
+ // label must contain non-whitespace characters
+ this.pos = startpos;
+ return 0;
+ }
+ var sourcepos = this.getReferenceDefSourcepos(block);
+ block.sourcepos[0][0] = sourcepos[1][0] + 1;
+ var node = createNode('refDef', sourcepos);
+ node.title = title;
+ node.dest = dest;
+ node.label = normalLabel;
+ block.insertBefore(node);
+ if (!refMap[normalLabel]) {
+ refMap[normalLabel] = createRefDefState(node);
+ }
+ else {
+ this.refDefCandidateMap[node.id] = node;
+ }
+ return this.pos - startpos;
+ };
+ InlineParser.prototype.mergeTextNodes = function (walker) {
+ var event;
+ var textNodes = [];
+ while ((event = walker.next())) {
+ var entering = event.entering, node = event.node;
+ if (entering && node.type === 'text') {
+ textNodes.push(node);
+ }
+ else if (textNodes.length === 1) {
+ textNodes = [];
+ }
+ else if (textNodes.length > 1) {
+ var firstNode = textNodes[0];
+ var lastNode = textNodes[textNodes.length - 1];
+ if (firstNode.sourcepos && lastNode.sourcepos) {
+ firstNode.sourcepos[1] = lastNode.sourcepos[1];
+ }
+ firstNode.next = lastNode.next;
+ if (firstNode.next) {
+ firstNode.next.prev = firstNode;
+ }
+ for (var i = 1; i < textNodes.length; i += 1) {
+ firstNode.literal += textNodes[i].literal;
+ textNodes[i].unlink();
+ }
+ textNodes = [];
+ }
+ }
+ };
+ InlineParser.prototype.getReferenceDefSourcepos = function (block) {
+ var lines = block.stringContent.split(/\n|\r\n/);
+ var passedUrlLine = false;
+ var quotationCount = 0;
+ var lastLineOffset = { line: 0, ch: 0 };
+ for (var i = 0; i < lines.length; i += 1) {
+ var line = lines[i];
+ if (reWhitespaceChar.test(line)) {
+ break;
+ }
+ if (/\:/.test(line) && quotationCount === 0) {
+ if (passedUrlLine) {
+ break;
+ }
+ var lineOffset = line.indexOf(':') === line.length - 1 ? i + 1 : i;
+ lastLineOffset = { line: lineOffset, ch: lines[lineOffset].length };
+ passedUrlLine = true;
+ }
+ // should consider extendable title
+ var matched = line.match(/'|"/g);
+ if (matched) {
+ quotationCount += matched.length;
+ }
+ if (quotationCount === 2) {
+ lastLineOffset = { line: i, ch: line.length };
+ break;
+ }
+ }
+ return [
+ [block.sourcepos[0][0], block.sourcepos[0][1]],
+ [block.sourcepos[0][0] + lastLineOffset.line, lastLineOffset.ch],
+ ];
+ };
+ // Parse the next inline element in subject, advancing subject position.
+ // On success, add the result to block's children and return true.
+ // On failure, return false.
+ InlineParser.prototype.parseInline = function (block) {
+ var _a;
+ var res = false;
+ var c = this.peek();
+ if (c === -1) {
+ return false;
+ }
+ switch (c) {
+ case C_NEWLINE:
+ res = this.parseNewline(block);
+ break;
+ case C_BACKSLASH:
+ res = this.parseBackslash(block);
+ break;
+ case C_BACKTICK:
+ res = this.parseBackticks(block);
+ break;
+ case C_ASTERISK:
+ case C_UNDERSCORE:
+ case C_TILDE:
+ case C_DOLLAR:
+ res = this.handleDelim(c, block);
+ break;
+ case C_SINGLEQUOTE:
+ case C_DOUBLEQUOTE:
+ res = !!((_a = this.options) === null || _a === void 0 ? void 0 : _a.smart) && this.handleDelim(c, block);
+ break;
+ case C_OPEN_BRACKET$1:
+ res = this.parseOpenBracket(block);
+ break;
+ case C_BANG:
+ res = this.parseBang(block);
+ break;
+ case C_CLOSE_BRACKET:
+ res = this.parseCloseBracket(block);
+ break;
+ case C_LESSTHAN$1:
+ res = this.parseAutolink(block) || this.parseHtmlTag(block);
+ break;
+ case C_AMPERSAND:
+ if (!block.disabledEntityParse) {
+ res = this.parseEntity(block);
+ }
+ break;
+ default:
+ res = this.parseString(block);
+ break;
+ }
+ if (!res) {
+ this.pos += 1;
+ block.appendChild(esm_text(fromCodePoint$1(c), this.sourcepos(this.pos, this.pos + 1)));
+ }
+ return true;
+ };
+ // Parse string content in block into inline children,
+ // using refmap to resolve references.
+ InlineParser.prototype.parse = function (block) {
+ this.subject = block.stringContent.trim();
+ this.pos = 0;
+ this.delimiters = null;
+ this.brackets = null;
+ this.lineOffsets = block.lineOffsets || [0];
+ this.lineIdx = 0;
+ this.linePosOffset = 0;
+ this.lineStartNum = block.sourcepos[0][0];
+ if (isHeading(block)) {
+ this.lineOffsets[0] += block.level + 1;
+ }
+ while (this.parseInline(block)) { }
+ block.stringContent = null; // allow raw string to be garbage collected
+ this.processEmphasis(null);
+ this.mergeTextNodes(block.walker());
+ var _a = this.options, extendedAutolinks = _a.extendedAutolinks, customParser = _a.customParser;
+ if (extendedAutolinks) {
+ convertExtAutoLinks(block.walker(), extendedAutolinks);
+ }
+ if (customParser && block.firstChild) {
+ var event_1;
+ var walker = block.firstChild.walker();
+ while ((event_1 = walker.next())) {
+ var node = event_1.node, entering = event_1.entering;
+ if (customParser[node.type]) {
+ customParser[node.type](node, { entering: entering, options: this.options });
+ }
+ }
+ }
+ };
+ return InlineParser;
+}());
+var reTaskListItemMarker = /^\[([ \txX])\][ \t]+/;
+// finalize for block handler
+function taskListItemFinalize(_, block) {
+ if (block.firstChild && block.firstChild.type === 'paragraph') {
+ var p = block.firstChild;
+ var m = p.stringContent.match(reTaskListItemMarker);
+ if (m) {
+ var mLen = m[0].length;
+ p.stringContent = p.stringContent.substring(mLen - 1);
+ p.sourcepos[0][1] += mLen;
+ p.lineOffsets[0] += mLen;
+ block.listData.task = true;
+ block.listData.checked = /[xX]/.test(m[1]);
+ }
+ }
+}
+var table = {
+ continue: function () {
+ return 0 /* Go */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t === 'tableHead' || t === 'tableBody';
+ },
+ acceptsLines: false,
+};
+var tableBody$1 = {
+ continue: function () {
+ return 0 /* Go */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t === 'tableRow';
+ },
+ acceptsLines: false,
+};
+var tableHead$1 = {
+ continue: function () {
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t === 'tableRow' || t === 'tableDelimRow';
+ },
+ acceptsLines: false,
+};
+var tableDelimRow = {
+ continue: function () {
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t === 'tableDelimCell';
+ },
+ acceptsLines: false,
+};
+var tableDelimCell = {
+ continue: function () {
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: false,
+};
+var tableRow = {
+ continue: function () {
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t === 'tableCell';
+ },
+ acceptsLines: false,
+};
+var tableCell = {
+ continue: function () {
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: false,
+};
+var CODE_INDENT = 4;
+var C_TAB = 9;
+var C_GREATERTHAN = 62;
+var C_LESSTHAN = 60;
+var C_SPACE = 32;
+var C_OPEN_BRACKET = 91;
+var reNonSpace = /[^ \t\f\v\r\n]/;
+var reClosingCodeFence = /^(?:`{3,}|~{3,})(?= *$)/;
+// Returns true if block ends with a blank line, descending if needed
+// into lists and sublists.
+function endsWithBlankLine(block) {
+ var curBlock = block;
+ while (curBlock) {
+ if (curBlock.lastLineBlank) {
+ return true;
+ }
+ var t = curBlock.type;
+ if (!curBlock.lastLineChecked && (t === 'list' || t === 'item')) {
+ curBlock.lastLineChecked = true;
+ curBlock = curBlock.lastChild;
+ }
+ else {
+ curBlock.lastLineChecked = true;
+ break;
+ }
+ }
+ return false;
+}
+function peek(ln, pos) {
+ if (pos < ln.length) {
+ return ln.charCodeAt(pos);
+ }
+ return -1;
+}
+// Returns true if string contains only space characters.
+function isBlank(s) {
+ return !reNonSpace.test(s);
+}
+function isSpaceOrTab(c) {
+ return c === C_SPACE || c === C_TAB;
+}
+var reClosingCustomBlock = /^\$\$$/;
+var customBlock$1 = {
+ continue: function (parser, container) {
+ var line = parser.currentLine;
+ var match = line.match(reClosingCustomBlock);
+ if (match) {
+ // closing custom block
+ parser.lastLineLength = match[0].length;
+ parser.finalize(container, parser.lineNumber);
+ return 2 /* Finished */;
+ }
+ // skip optional spaces of custom block offset
+ var i = container.offset;
+ while (i > 0 && isSpaceOrTab(peek(line, parser.offset))) {
+ parser.advanceOffset(1, true);
+ i--;
+ }
+ return 0 /* Go */;
+ },
+ finalize: function (_, block) {
+ if (block.stringContent === null) {
+ return;
+ }
+ // first line becomes info string
+ var content = block.stringContent;
+ var newlinePos = content.indexOf('\n');
+ var firstLine = content.slice(0, newlinePos);
+ var rest = content.slice(newlinePos + 1);
+ var infoString = firstLine.match(/^(\s*)(.*)/);
+ block.info = unescapeString(infoString[2].trim());
+ block.literal = rest;
+ block.stringContent = null;
+ },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: true,
+};
+var noop = {
+ continue: function () {
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: true,
+};
+var document$1 = {
+ continue: function () {
+ return 0 /* Go */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t !== 'item';
+ },
+ acceptsLines: false,
+};
+var list = {
+ continue: function () {
+ return 0 /* Go */;
+ },
+ finalize: function (_, block) {
+ var item = block.firstChild;
+ while (item) {
+ // check for non-final list item ending with blank line:
+ if (endsWithBlankLine(item) && item.next) {
+ block.listData.tight = false;
+ break;
+ }
+ // recurse into children of list item, to see if there are
+ // spaces between any of them:
+ var subitem = item.firstChild;
+ while (subitem) {
+ if (endsWithBlankLine(subitem) && (item.next || subitem.next)) {
+ block.listData.tight = false;
+ break;
+ }
+ subitem = subitem.next;
+ }
+ item = item.next;
+ }
+ },
+ canContain: function (t) {
+ return t === 'item';
+ },
+ acceptsLines: false,
+};
+var blockQuote$1 = {
+ continue: function (parser) {
+ var ln = parser.currentLine;
+ if (!parser.indented && peek(ln, parser.nextNonspace) === C_GREATERTHAN) {
+ parser.advanceNextNonspace();
+ parser.advanceOffset(1, false);
+ if (isSpaceOrTab(peek(ln, parser.offset))) {
+ parser.advanceOffset(1, true);
+ }
+ }
+ else {
+ return 1 /* Stop */;
+ }
+ return 0 /* Go */;
+ },
+ finalize: function () { },
+ canContain: function (t) {
+ return t !== 'item';
+ },
+ acceptsLines: false,
+};
+var esm_item = {
+ continue: function (parser, container) {
+ if (parser.blank) {
+ if (container.firstChild === null) {
+ // Blank line after empty list item
+ return 1 /* Stop */;
+ }
+ parser.advanceNextNonspace();
+ }
+ else if (parser.indent >= container.listData.markerOffset + container.listData.padding) {
+ parser.advanceOffset(container.listData.markerOffset + container.listData.padding, true);
+ }
+ else {
+ return 1 /* Stop */;
+ }
+ return 0 /* Go */;
+ },
+ finalize: taskListItemFinalize,
+ canContain: function (t) {
+ return t !== 'item';
+ },
+ acceptsLines: false,
+};
+var esm_heading = {
+ continue: function () {
+ // a heading can never container > 1 line, so fail to match:
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: false,
+};
+var thematicBreak$1 = {
+ continue: function () {
+ // a thematic break can never container > 1 line, so fail to match:
+ return 1 /* Stop */;
+ },
+ finalize: function () { },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: false,
+};
+var esm_codeBlock = {
+ continue: function (parser, container) {
+ var ln = parser.currentLine;
+ var indent = parser.indent;
+ if (container.isFenced) {
+ // fenced
+ var match = indent <= 3 &&
+ ln.charAt(parser.nextNonspace) === container.fenceChar &&
+ ln.slice(parser.nextNonspace).match(reClosingCodeFence);
+ if (match && match[0].length >= container.fenceLength) {
+ // closing fence - we're at end of line, so we can return
+ parser.lastLineLength = parser.offset + indent + match[0].length;
+ parser.finalize(container, parser.lineNumber);
+ return 2 /* Finished */;
+ }
+ // skip optional spaces of fence offset
+ var i = container.fenceOffset;
+ while (i > 0 && isSpaceOrTab(peek(ln, parser.offset))) {
+ parser.advanceOffset(1, true);
+ i--;
+ }
+ }
+ else {
+ // indented
+ if (indent >= CODE_INDENT) {
+ parser.advanceOffset(CODE_INDENT, true);
+ }
+ else if (parser.blank) {
+ parser.advanceNextNonspace();
+ }
+ else {
+ return 1 /* Stop */;
+ }
+ }
+ return 0 /* Go */;
+ },
+ finalize: function (_, block) {
+ var _a;
+ if (block.stringContent === null) {
+ return;
+ }
+ if (block.isFenced) {
+ // fenced
+ // first line becomes info string
+ var content = block.stringContent;
+ var newlinePos = content.indexOf('\n');
+ var firstLine = content.slice(0, newlinePos);
+ var rest = content.slice(newlinePos + 1);
+ var infoString = firstLine.match(/^(\s*)(.*)/);
+ block.infoPadding = infoString[1].length;
+ block.info = unescapeString(infoString[2].trim());
+ block.literal = rest;
+ }
+ else {
+ // indented
+ block.literal = (_a = block.stringContent) === null || _a === void 0 ? void 0 : _a.replace(/(\n *)+$/, '\n');
+ }
+ block.stringContent = null; // allow GC
+ },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: true,
+};
+var htmlBlock$1 = {
+ continue: function (parser, container) {
+ return parser.blank && (container.htmlBlockType === 6 || container.htmlBlockType === 7)
+ ? 1 /* Stop */
+ : 0 /* Go */;
+ },
+ finalize: function (_, block) {
+ var _a;
+ block.literal = ((_a = block.stringContent) === null || _a === void 0 ? void 0 : _a.replace(/(\n *)+$/, '')) || null;
+ block.stringContent = null; // allow GC
+ },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: true,
+};
+var paragraph = {
+ continue: function (parser) {
+ return parser.blank ? 1 /* Stop */ : 0 /* Go */;
+ },
+ finalize: function (parser, block) {
+ if (block.stringContent === null) {
+ return;
+ }
+ var pos;
+ var hasReferenceDefs = false;
+ // try parsing the beginning as link reference definitions:
+ while (peek(block.stringContent, 0) === C_OPEN_BRACKET &&
+ (pos = parser.inlineParser.parseReference(block, parser.refMap))) {
+ block.stringContent = block.stringContent.slice(pos);
+ hasReferenceDefs = true;
+ }
+ if (hasReferenceDefs && isBlank(block.stringContent)) {
+ block.unlink();
+ }
+ },
+ canContain: function () {
+ return false;
+ },
+ acceptsLines: true,
+};
+var refDef = noop;
+var frontMatter$2 = noop;
+var blockHandlers = {
+ document: document$1,
+ list: list,
+ blockQuote: blockQuote$1,
+ item: esm_item,
+ heading: esm_heading,
+ thematicBreak: thematicBreak$1,
+ codeBlock: esm_codeBlock,
+ htmlBlock: htmlBlock$1,
+ paragraph: paragraph,
+ table: table,
+ tableBody: tableBody$1,
+ tableHead: tableHead$1,
+ tableRow: tableRow,
+ tableCell: tableCell,
+ tableDelimRow: tableDelimRow,
+ tableDelimCell: tableDelimCell,
+ refDef: refDef,
+ customBlock: customBlock$1,
+ frontMatter: frontMatter$2,
+};
+function parseRowContent(content) {
+ var startIdx = 0;
+ var offset = 0;
+ var cells = [];
+ for (var i = 0; i < content.length; i += 1) {
+ if (content[i] === '|' && content[i - 1] !== '\\') {
+ var cell = content.substring(startIdx, i);
+ if (startIdx === 0 && isEmpty(cell)) {
+ offset = i + 1;
+ }
+ else {
+ cells.push(cell);
+ }
+ startIdx = i + 1;
+ }
+ }
+ if (startIdx < content.length) {
+ var cell = content.substring(startIdx, content.length);
+ if (!isEmpty(cell)) {
+ cells.push(cell);
+ }
+ }
+ return [offset, cells];
+}
+function generateTableCells(cellType, contents, lineNum, chPos) {
+ var cells = [];
+ for (var _i = 0, contents_1 = contents; _i < contents_1.length; _i++) {
+ var content = contents_1[_i];
+ var preSpaces = content.match(/^[ \t]+/);
+ var paddingLeft = preSpaces ? preSpaces[0].length : 0;
+ var paddingRight = void 0, trimmed = void 0;
+ if (paddingLeft === content.length) {
+ paddingLeft = 0;
+ paddingRight = 0;
+ trimmed = '';
+ }
+ else {
+ var postSpaces = content.match(/[ \t]+$/);
+ paddingRight = postSpaces ? postSpaces[0].length : 0;
+ trimmed = content.slice(paddingLeft, content.length - paddingRight);
+ }
+ var chPosStart = chPos + paddingLeft;
+ var tableCell = createNode(cellType, [
+ [lineNum, chPos],
+ [lineNum, chPos + content.length - 1],
+ ]);
+ tableCell.stringContent = trimmed.replace(/\\\|/g, '|'); // replace esacped pipe(\|)
+ tableCell.startIdx = cells.length;
+ tableCell.endIdx = cells.length;
+ tableCell.lineOffsets = [chPosStart - 1];
+ tableCell.paddingLeft = paddingLeft;
+ tableCell.paddingRight = paddingRight;
+ cells.push(tableCell);
+ chPos += content.length + 1;
+ }
+ return cells;
+}
+function getColumnFromDelimCell(cellNode) {
+ var align = null;
+ var content = cellNode.stringContent;
+ var firstCh = content[0];
+ var lastCh = content[content.length - 1];
+ if (lastCh === ':') {
+ align = firstCh === ':' ? 'center' : 'right';
+ }
+ else if (firstCh === ':') {
+ align = 'left';
+ }
+ return { align: align };
+}
+var tableHead = function (parser, container) {
+ var stringContent = container.stringContent;
+ if (container.type === 'paragraph' && !parser.indented && !parser.blank) {
+ var lastNewLineIdx = stringContent.length - 1;
+ var lastLineStartIdx = stringContent.lastIndexOf('\n', lastNewLineIdx - 1) + 1;
+ var headerContent = stringContent.slice(lastLineStartIdx, lastNewLineIdx);
+ var delimContent = parser.currentLine.slice(parser.nextNonspace);
+ var _a = parseRowContent(headerContent), headerOffset = _a[0], headerCells = _a[1];
+ var _b = parseRowContent(delimContent), delimOffset = _b[0], delimCells = _b[1];
+ var reValidDelimCell_1 = /^[ \t]*:?-+:?[ \t]*$/;
+ if (
+ // not checking if the number of header cells and delimiter cells are the same
+ // to consider the case of merged-column (via plugin)
+ !headerCells.length ||
+ !delimCells.length ||
+ delimCells.some(function (cell) { return !reValidDelimCell_1.test(cell); }) ||
+ // to prevent to regard setTextHeading as tabel delim cell with 'disallowDeepHeading' option
+ (delimCells.length === 1 && delimContent.indexOf('|') !== 0)) {
+ return 0 /* None */;
+ }
+ var lineOffsets = container.lineOffsets;
+ var firstLineNum = parser.lineNumber - 1;
+ var firstLineStart = esm_last(lineOffsets) + 1;
+ var table = createNode('table', [
+ [firstLineNum, firstLineStart],
+ [parser.lineNumber, parser.offset],
+ ]);
+ // eslint-disable-next-line arrow-body-style
+ table.columns = delimCells.map(function () { return ({ align: null }); });
+ container.insertAfter(table);
+ if (lineOffsets.length === 1) {
+ container.unlink();
+ }
+ else {
+ container.stringContent = stringContent.slice(0, lastLineStartIdx);
+ var paraLastLineStartIdx = stringContent.lastIndexOf('\n', lastLineStartIdx - 2) + 1;
+ var paraLastLineLen = lastLineStartIdx - paraLastLineStartIdx - 1;
+ parser.lastLineLength = lineOffsets[lineOffsets.length - 2] + paraLastLineLen;
+ parser.finalize(container, firstLineNum - 1);
+ }
+ parser.advanceOffset(parser.currentLine.length - parser.offset, false);
+ var tableHead_1 = createNode('tableHead', [
+ [firstLineNum, firstLineStart],
+ [parser.lineNumber, parser.offset],
+ ]);
+ table.appendChild(tableHead_1);
+ var tableHeadRow_1 = createNode('tableRow', [
+ [firstLineNum, firstLineStart],
+ [firstLineNum, firstLineStart + headerContent.length - 1],
+ ]);
+ var tableDelimRow_1 = createNode('tableDelimRow', [
+ [parser.lineNumber, parser.nextNonspace + 1],
+ [parser.lineNumber, parser.offset],
+ ]);
+ tableHead_1.appendChild(tableHeadRow_1);
+ tableHead_1.appendChild(tableDelimRow_1);
+ generateTableCells('tableCell', headerCells, firstLineNum, firstLineStart + headerOffset).forEach(function (cellNode) {
+ tableHeadRow_1.appendChild(cellNode);
+ });
+ var delimCellNodes = generateTableCells('tableDelimCell', delimCells, parser.lineNumber, parser.nextNonspace + 1 + delimOffset);
+ delimCellNodes.forEach(function (cellNode) {
+ tableDelimRow_1.appendChild(cellNode);
+ });
+ table.columns = delimCellNodes.map(getColumnFromDelimCell);
+ parser.tip = table;
+ return 2 /* Leaf */;
+ }
+ return 0 /* None */;
+};
+var tableBody = function (parser, container) {
+ if ((container.type !== 'table' && container.type !== 'tableBody') ||
+ (!parser.blank && parser.currentLine.indexOf('|') === -1)) {
+ return 0 /* None */;
+ }
+ parser.advanceOffset(parser.currentLine.length - parser.offset, false);
+ if (parser.blank) {
+ var table_1 = container;
+ if (container.type === 'tableBody') {
+ table_1 = container.parent;
+ parser.finalize(container, parser.lineNumber - 1);
+ }
+ parser.finalize(table_1, parser.lineNumber - 1);
+ return 0 /* None */;
+ }
+ var tableBody = container;
+ if (container.type === 'table') {
+ tableBody = parser.addChild('tableBody', parser.nextNonspace);
+ tableBody.stringContent = null;
+ }
+ var tableRow = createNode('tableRow', [
+ [parser.lineNumber, parser.nextNonspace + 1],
+ [parser.lineNumber, parser.currentLine.length],
+ ]);
+ tableBody.appendChild(tableRow);
+ var table = tableBody.parent;
+ var content = parser.currentLine.slice(parser.nextNonspace);
+ var _a = parseRowContent(content), offset = _a[0], cellContents = _a[1];
+ generateTableCells('tableCell', cellContents, parser.lineNumber, parser.nextNonspace + 1 + offset).forEach(function (cellNode, idx) {
+ if (idx >= table.columns.length) {
+ cellNode.ignored = true;
+ }
+ tableRow.appendChild(cellNode);
+ });
+ return 2 /* Leaf */;
+};
+var reCustomBlock = /^(\$\$)(\s*[a-zA-Z])+/;
+var reCanBeCustomInline = /^(\$\$)(\s*[a-zA-Z])+.*(\$\$)/;
+var esm_customBlock = function (parser) {
+ var match;
+ if (!parser.indented &&
+ !reCanBeCustomInline.test(parser.currentLine) &&
+ (match = parser.currentLine.match(reCustomBlock))) {
+ var syntaxLength = match[1].length;
+ parser.closeUnmatchedBlocks();
+ var container = parser.addChild('customBlock', parser.nextNonspace);
+ container.syntaxLength = syntaxLength;
+ container.offset = parser.indent;
+ parser.advanceNextNonspace();
+ parser.advanceOffset(syntaxLength, false);
+ return 2 /* Leaf */;
+ }
+ return 0 /* None */;
+};
+var reCodeFence = /^`{3,}(?!.*`)|^~{3,}/;
+var reHtmlBlockOpen = [
+ /./,
+ /^<(?:script|pre|style)(?:\s|>|$)/i,
+ /^/,
+ /\?>/,
+ />/,
+ /\]\]>/,
+];
+var reMaybeSpecial = /^[#`~*+_=<>0-9-;$]/;
+var reLineEnding$1 = /\r\n|\n|\r/;
+function esm_document() {
+ return createNode('document', [
+ [1, 1],
+ [0, 0],
+ ]);
+}
+var defaultOptions$1 = {
+ smart: false,
+ tagFilter: false,
+ extendedAutolinks: false,
+ disallowedHtmlBlockTags: [],
+ referenceDefinition: false,
+ disallowDeepHeading: false,
+ customParser: null,
+ frontMatter: false,
+};
+var Parser = /** @class */ (function () {
+ function Parser(options) {
+ this.options = esm_assign(esm_assign({}, defaultOptions$1), options);
+ this.doc = esm_document();
+ this.tip = this.doc;
+ this.oldtip = this.doc;
+ this.lineNumber = 0;
+ this.offset = 0;
+ this.column = 0;
+ this.nextNonspace = 0;
+ this.nextNonspaceColumn = 0;
+ this.indent = 0;
+ this.currentLine = '';
+ this.indented = false;
+ this.blank = false;
+ this.partiallyConsumedTab = false;
+ this.allClosed = true;
+ this.lastMatchedContainer = this.doc;
+ this.refMap = {};
+ this.refLinkCandidateMap = {};
+ this.refDefCandidateMap = {};
+ this.lastLineLength = 0;
+ this.lines = [];
+ if (this.options.frontMatter) {
+ blockHandlers.frontMatter = frontMatter;
+ blockStarts.unshift(frontMatter$1);
+ }
+ this.inlineParser = new InlineParser(this.options);
+ }
+ Parser.prototype.advanceOffset = function (count, columns) {
+ if (columns === void 0) {
+ columns = false;
+ }
+ var currentLine = this.currentLine;
+ var charsToTab, charsToAdvance;
+ var c;
+ while (count > 0 && (c = currentLine[this.offset])) {
+ if (c === '\t') {
+ charsToTab = 4 - (this.column % 4);
+ if (columns) {
+ this.partiallyConsumedTab = charsToTab > count;
+ charsToAdvance = charsToTab > count ? count : charsToTab;
+ this.column += charsToAdvance;
+ this.offset += this.partiallyConsumedTab ? 0 : 1;
+ count -= charsToAdvance;
+ }
+ else {
+ this.partiallyConsumedTab = false;
+ this.column += charsToTab;
+ this.offset += 1;
+ count -= 1;
+ }
+ }
+ else {
+ this.partiallyConsumedTab = false;
+ this.offset += 1;
+ this.column += 1; // assume ascii; block starts are ascii
+ count -= 1;
+ }
+ }
+ };
+ Parser.prototype.advanceNextNonspace = function () {
+ this.offset = this.nextNonspace;
+ this.column = this.nextNonspaceColumn;
+ this.partiallyConsumedTab = false;
+ };
+ Parser.prototype.findNextNonspace = function () {
+ var currentLine = this.currentLine;
+ var i = this.offset;
+ var cols = this.column;
+ var c;
+ while ((c = currentLine.charAt(i)) !== '') {
+ if (c === ' ') {
+ i++;
+ cols++;
+ }
+ else if (c === '\t') {
+ i++;
+ cols += 4 - (cols % 4);
+ }
+ else {
+ break;
+ }
+ }
+ this.blank = c === '\n' || c === '\r' || c === '';
+ this.nextNonspace = i;
+ this.nextNonspaceColumn = cols;
+ this.indent = this.nextNonspaceColumn - this.column;
+ this.indented = this.indent >= CODE_INDENT;
+ };
+ // Add a line to the block at the tip. We assume the tip
+ // can accept lines -- that check should be done before calling this.
+ Parser.prototype.addLine = function () {
+ if (this.partiallyConsumedTab) {
+ this.offset += 1; // skip over tab
+ // add space characters:
+ var charsToTab = 4 - (this.column % 4);
+ this.tip.stringContent += esm_repeat(' ', charsToTab);
+ }
+ if (this.tip.lineOffsets) {
+ this.tip.lineOffsets.push(this.offset);
+ }
+ else {
+ this.tip.lineOffsets = [this.offset];
+ }
+ this.tip.stringContent += this.currentLine.slice(this.offset) + "\n";
+ };
+ // Add block of type tag as a child of the tip. If the tip can't
+ // accept children, close and finalize it and try its parent,
+ // and so on til we find a block that can accept children.
+ Parser.prototype.addChild = function (tag, offset) {
+ while (!blockHandlers[this.tip.type].canContain(tag)) {
+ this.finalize(this.tip, this.lineNumber - 1);
+ }
+ var columnNumber = offset + 1; // offset 0 = column 1
+ var newBlock = createNode(tag, [
+ [this.lineNumber, columnNumber],
+ [0, 0],
+ ]);
+ newBlock.stringContent = '';
+ this.tip.appendChild(newBlock);
+ this.tip = newBlock;
+ return newBlock;
+ };
+ // Finalize and close any unmatched blocks.
+ Parser.prototype.closeUnmatchedBlocks = function () {
+ if (!this.allClosed) {
+ // finalize any blocks not matched
+ while (this.oldtip !== this.lastMatchedContainer) {
+ var parent_1 = this.oldtip.parent;
+ this.finalize(this.oldtip, this.lineNumber - 1);
+ this.oldtip = parent_1;
+ }
+ this.allClosed = true;
+ }
+ };
+ // Finalize a block. Close it and do any necessary postprocessing,
+ // e.g. creating stringContent from strings, setting the 'tight'
+ // or 'loose' status of a list, and parsing the beginnings
+ // of paragraphs for reference definitions. Reset the tip to the
+ // parent of the closed block.
+ Parser.prototype.finalize = function (block, lineNumber) {
+ var above = block.parent;
+ block.open = false;
+ block.sourcepos[1] = [lineNumber, this.lastLineLength];
+ blockHandlers[block.type].finalize(this, block);
+ this.tip = above;
+ };
+ // Walk through a block & children recursively, parsing string content
+ // into inline content where appropriate.
+ Parser.prototype.processInlines = function (block) {
+ var event;
+ var customParser = this.options.customParser;
+ var walker = block.walker();
+ this.inlineParser.refMap = this.refMap;
+ this.inlineParser.refLinkCandidateMap = this.refLinkCandidateMap;
+ this.inlineParser.refDefCandidateMap = this.refDefCandidateMap;
+ this.inlineParser.options = this.options;
+ while ((event = walker.next())) {
+ var node = event.node, entering = event.entering;
+ var t = node.type;
+ if (customParser && customParser[t]) {
+ customParser[t](node, { entering: entering, options: this.options });
+ }
+ if (!entering &&
+ (t === 'paragraph' ||
+ t === 'heading' ||
+ (t === 'tableCell' && !node.ignored))) {
+ this.inlineParser.parse(node);
+ }
+ }
+ };
+ // Analyze a line of text and update the document appropriately.
+ // We parse markdown text by calling this on each line of input,
+ // then finalizing the document.
+ Parser.prototype.incorporateLine = function (ln) {
+ var container = this.doc;
+ this.oldtip = this.tip;
+ this.offset = 0;
+ this.column = 0;
+ this.blank = false;
+ this.partiallyConsumedTab = false;
+ this.lineNumber += 1;
+ // replace NUL characters for security
+ if (ln.indexOf('\u0000') !== -1) {
+ ln = ln.replace(/\0/g, '\uFFFD');
+ }
+ this.currentLine = ln;
+ // For each containing block, try to parse the associated line start.
+ // Bail out on failure: container will point to the last matching block.
+ // Set allMatched to false if not all containers match.
+ var allMatched = true;
+ var lastChild;
+ while ((lastChild = container.lastChild) && lastChild.open) {
+ container = lastChild;
+ this.findNextNonspace();
+ switch (blockHandlers[container.type]['continue'](this, container)) {
+ case 0 /* Go */: // we've matched, keep going
+ break;
+ case 1 /* Stop */: // we've failed to match a block
+ allMatched = false;
+ break;
+ case 2 /* Finished */: // we've hit end of line for fenced code close and can return
+ this.lastLineLength = ln.length;
+ return;
+ default:
+ throw new Error('continue returned illegal value, must be 0, 1, or 2');
+ }
+ if (!allMatched) {
+ container = container.parent; // back up to last matching block
+ break;
+ }
+ }
+ this.allClosed = container === this.oldtip;
+ this.lastMatchedContainer = container;
+ var matchedLeaf = container.type !== 'paragraph' && blockHandlers[container.type].acceptsLines;
+ var blockStartsLen = blockStarts.length;
+ // Unless last matched container is a code block, try new container starts,
+ // adding children to the last matched container:
+ while (!matchedLeaf) {
+ this.findNextNonspace();
+ // this is a little performance optimization:
+ if (container.type !== 'table' &&
+ container.type !== 'tableBody' &&
+ container.type !== 'paragraph' &&
+ !this.indented &&
+ !reMaybeSpecial.test(ln.slice(this.nextNonspace))) {
+ this.advanceNextNonspace();
+ break;
+ }
+ var i = 0;
+ while (i < blockStartsLen) {
+ var res = blockStarts[i](this, container);
+ if (res === 1 /* Container */) {
+ container = this.tip;
+ break;
+ }
+ else if (res === 2 /* Leaf */) {
+ container = this.tip;
+ matchedLeaf = true;
+ break;
+ }
+ else {
+ i++;
+ }
+ }
+ if (i === blockStartsLen) {
+ // nothing matched
+ this.advanceNextNonspace();
+ break;
+ }
+ }
+ // What remains at the offset is a text line. Add the text to the
+ // appropriate container.
+ // First check for a lazy paragraph continuation:
+ if (!this.allClosed && !this.blank && this.tip.type === 'paragraph') {
+ // lazy paragraph continuation
+ this.addLine();
+ }
+ else {
+ // not a lazy continuation
+ // finalize any blocks not matched
+ this.closeUnmatchedBlocks();
+ if (this.blank && container.lastChild) {
+ container.lastChild.lastLineBlank = true;
+ }
+ var t = container.type;
+ // Block quote lines are never blank as they start with >
+ // and we don't count blanks in fenced code for purposes of tight/loose
+ // lists or breaking out of lists. We also don't set _lastLineBlank
+ // on an empty list item, or if we just closed a fenced block.
+ var lastLineBlank = this.blank &&
+ !(t === 'blockQuote' ||
+ (isCodeBlock(container) && container.isFenced) ||
+ (t === 'item' && !container.firstChild && container.sourcepos[0][0] === this.lineNumber));
+ // propagate lastLineBlank up through parents:
+ var cont = container;
+ while (cont) {
+ cont.lastLineBlank = lastLineBlank;
+ cont = cont.parent;
+ }
+ if (blockHandlers[t].acceptsLines) {
+ this.addLine();
+ // if HtmlBlock, check for end condition
+ if (isHtmlBlock(container) &&
+ container.htmlBlockType >= 1 &&
+ container.htmlBlockType <= 5 &&
+ reHtmlBlockClose[container.htmlBlockType].test(this.currentLine.slice(this.offset))) {
+ this.lastLineLength = ln.length;
+ this.finalize(container, this.lineNumber);
+ }
+ }
+ else if (this.offset < ln.length && !this.blank) {
+ // create paragraph container for line
+ container = this.addChild('paragraph', this.offset);
+ this.advanceNextNonspace();
+ this.addLine();
+ }
+ }
+ this.lastLineLength = ln.length;
+ };
+ // The main parsing function. Returns a parsed document AST.
+ Parser.prototype.parse = function (input, lineTexts) {
+ this.doc = esm_document();
+ this.tip = this.doc;
+ this.lineNumber = 0;
+ this.lastLineLength = 0;
+ this.offset = 0;
+ this.column = 0;
+ this.lastMatchedContainer = this.doc;
+ this.currentLine = '';
+ var lines = input.split(reLineEnding$1);
+ var len = lines.length;
+ this.lines = lineTexts ? lineTexts : lines;
+ if (this.options.referenceDefinition) {
+ this.clearRefMaps();
+ }
+ if (input.charCodeAt(input.length - 1) === C_NEWLINE) {
+ // ignore last blank line created by final newline
+ len -= 1;
+ }
+ for (var i = 0; i < len; i++) {
+ this.incorporateLine(lines[i]);
+ }
+ while (this.tip) {
+ this.finalize(this.tip, len);
+ }
+ this.processInlines(this.doc);
+ return this.doc;
+ };
+ Parser.prototype.partialParseStart = function (lineNumber, lines) {
+ this.doc = esm_document();
+ this.tip = this.doc;
+ this.lineNumber = lineNumber - 1;
+ this.lastLineLength = 0;
+ this.offset = 0;
+ this.column = 0;
+ this.lastMatchedContainer = this.doc;
+ this.currentLine = '';
+ var len = lines.length;
+ for (var i = 0; i < len; i++) {
+ this.incorporateLine(lines[i]);
+ }
+ return this.doc;
+ };
+ Parser.prototype.partialParseExtends = function (lines) {
+ for (var i = 0; i < lines.length; i++) {
+ this.incorporateLine(lines[i]);
+ }
+ };
+ Parser.prototype.partialParseFinish = function () {
+ while (this.tip) {
+ this.finalize(this.tip, this.lineNumber);
+ }
+ this.processInlines(this.doc);
+ };
+ Parser.prototype.setRefMaps = function (refMap, refLinkCandidateMap, refDefCandidateMap) {
+ this.refMap = refMap;
+ this.refLinkCandidateMap = refLinkCandidateMap;
+ this.refDefCandidateMap = refDefCandidateMap;
+ };
+ Parser.prototype.clearRefMaps = function () {
+ [this.refMap, this.refLinkCandidateMap, this.refDefCandidateMap].forEach(function (map) {
+ clearObj(map);
+ });
+ };
+ return Parser;
+}());
+function comparePos(p1, p2) {
+ if (p1[0] < p2[0]) {
+ return 1 /* LT */;
+ }
+ if (p1[0] > p2[0]) {
+ return -1 /* GT */;
+ }
+ if (p1[1] < p2[1]) {
+ return 1 /* LT */;
+ }
+ if (p1[1] > p2[1]) {
+ return -1 /* GT */;
+ }
+ return 0 /* EQ */;
+}
+function compareRangeAndPos(_a, pos) {
+ var startPos = _a[0], endPos = _a[1];
+ if (comparePos(endPos, pos) === 1 /* LT */) {
+ return 1 /* LT */;
+ }
+ if (comparePos(startPos, pos) === -1 /* GT */) {
+ return -1 /* GT */;
+ }
+ return 0 /* EQ */;
+}
+function removeNextUntil(node, last) {
+ if (node.parent !== last.parent || node === last) {
+ return;
+ }
+ var next = node.next;
+ while (next && next !== last) {
+ var temp = next.next;
+ for (var _i = 0, _a = ['parent', 'prev', 'next']; _i < _a.length; _i++) {
+ var type = _a[_i];
+ if (next[type]) {
+ removeNodeById(next[type].id);
+ next[type] = null;
+ }
+ }
+ next = temp;
+ }
+ node.next = last.next;
+ if (last.next) {
+ last.next.prev = node;
+ }
+ else {
+ node.parent.lastChild = node;
+ }
+}
+function getChildNodes(parent) {
+ var nodes = [];
+ var curr = parent.firstChild;
+ while (curr) {
+ nodes.push(curr);
+ curr = curr.next;
+ }
+ return nodes;
+}
+function insertNodesBefore(target, nodes) {
+ for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+ var node = nodes_1[_i];
+ target.insertBefore(node);
+ }
+}
+function prependChildNodes(parent, nodes) {
+ for (var i = nodes.length - 1; i >= 0; i -= 1) {
+ parent.prependChild(nodes[i]);
+ }
+}
+function updateNextLineNumbers(base, diff) {
+ if (!base || !base.parent || diff === 0) {
+ return;
+ }
+ var walker = base.parent.walker();
+ walker.resumeAt(base, true);
+ var event;
+ while ((event = walker.next())) {
+ var node = event.node, entering = event.entering;
+ if (entering) {
+ node.sourcepos[0][0] += diff;
+ node.sourcepos[1][0] += diff;
+ }
+ }
+}
+function compareRangeAndLine(_a, line) {
+ var startPos = _a[0], endPos = _a[1];
+ if (endPos[0] < line) {
+ return 1 /* LT */;
+ }
+ if (startPos[0] > line) {
+ return -1 /* GT */;
+ }
+ return 0 /* EQ */;
+}
+function findChildNodeAtLine(parent, line) {
+ var node = parent.firstChild;
+ while (node) {
+ var comp = compareRangeAndLine(node.sourcepos, line);
+ if (comp === 0 /* EQ */) {
+ return node;
+ }
+ if (comp === -1 /* GT */) {
+ // To consider that top line is blank line
+ return node.prev || node;
+ }
+ node = node.next;
+ }
+ return parent.lastChild;
+}
+function lastLeafNode(node) {
+ while (node.lastChild) {
+ node = node.lastChild;
+ }
+ return node;
+}
+function sameLineTopAncestor(node) {
+ while (node.parent &&
+ node.parent.type !== 'document' &&
+ node.parent.sourcepos[0][0] === node.sourcepos[0][0]) {
+ node = node.parent;
+ }
+ return node;
+}
+function findFirstNodeAtLine(parent, line) {
+ var node = parent.firstChild;
+ var prev = null;
+ while (node) {
+ var comp = compareRangeAndLine(node.sourcepos, line);
+ if (comp === 0 /* EQ */) {
+ if (node.sourcepos[0][0] === line || !node.firstChild) {
+ return node;
+ }
+ prev = node;
+ node = node.firstChild;
+ }
+ else if (comp === -1 /* GT */) {
+ break;
+ }
+ else {
+ prev = node;
+ node = node.next;
+ }
+ }
+ if (prev) {
+ return sameLineTopAncestor(lastLeafNode(prev));
+ }
+ return null;
+}
+function findNodeAtPosition(parent, pos) {
+ var node = parent;
+ var prev = null;
+ while (node) {
+ var comp = compareRangeAndPos(node.sourcepos, pos);
+ if (comp === 0 /* EQ */) {
+ if (node.firstChild) {
+ prev = node;
+ node = node.firstChild;
+ }
+ else {
+ return node;
+ }
+ }
+ else if (comp === -1 /* GT */) {
+ return prev;
+ }
+ else if (node.next) {
+ node = node.next;
+ }
+ else {
+ return prev;
+ }
+ }
+ return node;
+}
+function findNodeById(id) {
+ return getNodeById(id) || null;
+}
+function invokeNextUntil(callback, start, end) {
+ if (end === void 0) {
+ end = null;
+ }
+ if (start) {
+ var walker = start.walker();
+ while (start && start !== end) {
+ callback(start);
+ var next = walker.next();
+ if (next) {
+ start = next.node;
+ }
+ else {
+ break;
+ }
+ }
+ }
+}
+function isUnlinked(id) {
+ var node = findNodeById(id);
+ if (!node) {
+ return true;
+ }
+ while (node && node.type !== 'document') {
+ // eslint-disable-next-line no-loop-func
+ if (!node.parent && !node.prev && !node.next) {
+ return true;
+ }
+ node = node.parent;
+ }
+ return false;
+}
+var esm_reLineEnding = /\r\n|\n|\r/;
+function canBeContinuedListItem(lineText) {
+ var spaceMatch = lineText.match(/^[ \t]+/);
+ if (spaceMatch && (spaceMatch[0].length >= 2 || /\t/.test(spaceMatch[0]))) {
+ return true;
+ }
+ var leftTrimmed = spaceMatch ? lineText.slice(spaceMatch.length) : lineText;
+ return reBulletListMarker.test(leftTrimmed) || reOrderedListMarker.test(leftTrimmed);
+}
+function canBeContinuedTableBody(lineText) {
+ return !isBlank(lineText) && lineText.indexOf('|') !== -1;
+}
+function createRefDefState(node) {
+ var id = node.id, title = node.title, sourcepos = node.sourcepos, dest = node.dest;
+ return {
+ id: id,
+ title: title,
+ sourcepos: sourcepos,
+ unlinked: false,
+ destination: dest,
+ };
+}
+var ToastMark = /** @class */ (function () {
+ function ToastMark(contents, options) {
+ this.refMap = {};
+ this.refLinkCandidateMap = {};
+ this.refDefCandidateMap = {};
+ this.referenceDefinition = !!(options === null || options === void 0 ? void 0 : options.referenceDefinition);
+ this.parser = new Parser(options);
+ this.parser.setRefMaps(this.refMap, this.refLinkCandidateMap, this.refDefCandidateMap);
+ this.eventHandlerMap = { change: [] };
+ contents = contents || '';
+ this.lineTexts = contents.split(esm_reLineEnding);
+ this.root = this.parser.parse(contents, this.lineTexts);
+ }
+ ToastMark.prototype.updateLineTexts = function (startPos, endPos, newText) {
+ var _a;
+ var startLine = startPos[0], startCol = startPos[1];
+ var endLine = endPos[0], endCol = endPos[1];
+ var newLines = newText.split(esm_reLineEnding);
+ var newLineLen = newLines.length;
+ var startLineText = this.lineTexts[startLine - 1];
+ var endLineText = this.lineTexts[endLine - 1];
+ newLines[0] = startLineText.slice(0, startCol - 1) + newLines[0];
+ newLines[newLineLen - 1] = newLines[newLineLen - 1] + endLineText.slice(endCol - 1);
+ var removedLineLen = endLine - startLine + 1;
+ (_a = this.lineTexts).splice.apply(_a, esm_spreadArray([startLine - 1, removedLineLen], newLines));
+ return newLineLen - removedLineLen;
+ };
+ ToastMark.prototype.updateRootNodeState = function () {
+ if (this.lineTexts.length === 1 && this.lineTexts[0] === '') {
+ this.root.lastLineBlank = true;
+ this.root.sourcepos = [
+ [1, 1],
+ [1, 0],
+ ];
+ return;
+ }
+ if (this.root.lastChild) {
+ this.root.lastLineBlank = this.root.lastChild.lastLineBlank;
+ }
+ var lineTexts = this.lineTexts;
+ var idx = lineTexts.length - 1;
+ while (lineTexts[idx] === '') {
+ idx -= 1;
+ }
+ if (lineTexts.length - 2 > idx) {
+ idx += 1;
+ }
+ this.root.sourcepos[1] = [idx + 1, lineTexts[idx].length];
+ };
+ ToastMark.prototype.replaceRangeNodes = function (startNode, endNode, newNodes) {
+ if (!startNode) {
+ if (endNode) {
+ insertNodesBefore(endNode, newNodes);
+ removeNodeById(endNode.id);
+ endNode.unlink();
+ }
+ else {
+ prependChildNodes(this.root, newNodes);
+ }
+ }
+ else {
+ insertNodesBefore(startNode, newNodes);
+ removeNextUntil(startNode, endNode);
+ [startNode.id, endNode.id].forEach(function (id) { return removeNodeById(id); });
+ startNode.unlink();
+ }
+ };
+ ToastMark.prototype.getNodeRange = function (startPos, endPos) {
+ var startNode = findChildNodeAtLine(this.root, startPos[0]);
+ var endNode = findChildNodeAtLine(this.root, endPos[0]);
+ // extend node range to include a following block which doesn't have preceding blank line
+ if (endNode && endNode.next && endPos[0] + 1 === endNode.next.sourcepos[0][0]) {
+ endNode = endNode.next;
+ }
+ return [startNode, endNode];
+ };
+ ToastMark.prototype.trigger = function (eventName, param) {
+ this.eventHandlerMap[eventName].forEach(function (handler) {
+ handler(param);
+ });
+ };
+ ToastMark.prototype.extendEndLine = function (line) {
+ while (this.lineTexts[line] === '') {
+ line += 1;
+ }
+ return line;
+ };
+ ToastMark.prototype.parseRange = function (startNode, endNode, startLine, endLine) {
+ // extends starting range if the first node can be a continued list item
+ if (startNode &&
+ startNode.prev &&
+ ((isList(startNode.prev) && canBeContinuedListItem(this.lineTexts[startLine - 1])) ||
+ (isTable(startNode.prev) && canBeContinuedTableBody(this.lineTexts[startLine - 1])))) {
+ startNode = startNode.prev;
+ startLine = startNode.sourcepos[0][0];
+ }
+ var editedLines = this.lineTexts.slice(startLine - 1, endLine);
+ var root = this.parser.partialParseStart(startLine, editedLines);
+ // extends ending range if the following node can be a fenced code block or a continued list item
+ var nextNode = endNode ? endNode.next : this.root.firstChild;
+ var lastChild = root.lastChild;
+ var isOpenedLastChildCodeBlock = lastChild && isCodeBlock(lastChild) && lastChild.open;
+ var isOpenedLastChildCustomBlock = lastChild && isCustomBlock(lastChild) && lastChild.open;
+ var isLastChildList = lastChild && isList(lastChild);
+ while (((isOpenedLastChildCodeBlock || isOpenedLastChildCustomBlock) && nextNode) ||
+ (isLastChildList && nextNode && (nextNode.type === 'list' || nextNode.sourcepos[0][1] >= 2))) {
+ var newEndLine = this.extendEndLine(nextNode.sourcepos[1][0]);
+ this.parser.partialParseExtends(this.lineTexts.slice(endLine, newEndLine));
+ if (!startNode) {
+ startNode = endNode;
+ }
+ endNode = nextNode;
+ endLine = newEndLine;
+ nextNode = nextNode.next;
+ }
+ this.parser.partialParseFinish();
+ var newNodes = getChildNodes(root);
+ return { newNodes: newNodes, extStartNode: startNode, extEndNode: endNode };
+ };
+ ToastMark.prototype.getRemovedNodeRange = function (extStartNode, extEndNode) {
+ if (!extStartNode ||
+ (extStartNode && isRefDef(extStartNode)) ||
+ (extEndNode && isRefDef(extEndNode))) {
+ return null;
+ }
+ return {
+ id: [extStartNode.id, extEndNode.id],
+ line: [extStartNode.sourcepos[0][0] - 1, extEndNode.sourcepos[1][0] - 1],
+ };
+ };
+ ToastMark.prototype.markDeletedRefMap = function (extStartNode, extEndNode) {
+ var _this = this;
+ if (!isEmptyObj(this.refMap)) {
+ var markDeleted = function (node) {
+ if (isRefDef(node)) {
+ var refDefState = _this.refMap[node.label];
+ if (refDefState && node.id === refDefState.id) {
+ refDefState.unlinked = true;
+ }
+ }
+ };
+ if (extStartNode) {
+ invokeNextUntil(markDeleted, extStartNode.parent, extEndNode);
+ }
+ if (extEndNode) {
+ invokeNextUntil(markDeleted, extEndNode);
+ }
+ }
+ };
+ ToastMark.prototype.replaceWithNewRefDefState = function (nodes) {
+ var _this = this;
+ if (!isEmptyObj(this.refMap)) {
+ var replaceWith_1 = function (node) {
+ if (isRefDef(node)) {
+ var label = node.label;
+ var refDefState = _this.refMap[label];
+ if (!refDefState || refDefState.unlinked) {
+ _this.refMap[label] = createRefDefState(node);
+ }
+ }
+ };
+ nodes.forEach(function (node) {
+ invokeNextUntil(replaceWith_1, node);
+ });
+ }
+ };
+ ToastMark.prototype.replaceWithRefDefCandidate = function () {
+ var _this = this;
+ if (!isEmptyObj(this.refDefCandidateMap)) {
+ iterateObject(this.refDefCandidateMap, function (_, candidate) {
+ var label = candidate.label, sourcepos = candidate.sourcepos;
+ var refDefState = _this.refMap[label];
+ if (!refDefState ||
+ refDefState.unlinked ||
+ refDefState.sourcepos[0][0] > sourcepos[0][0]) {
+ _this.refMap[label] = createRefDefState(candidate);
+ }
+ });
+ }
+ };
+ ToastMark.prototype.getRangeWithRefDef = function (startLine, endLine, startNode, endNode, lineDiff) {
+ if (this.referenceDefinition && !isEmptyObj(this.refMap)) {
+ var prevNode = findChildNodeAtLine(this.root, startLine - 1);
+ var nextNode = findChildNodeAtLine(this.root, endLine + 1);
+ if (prevNode && isRefDef(prevNode) && prevNode !== startNode && prevNode !== endNode) {
+ startNode = prevNode;
+ startLine = startNode.sourcepos[0][0];
+ }
+ if (nextNode && isRefDef(nextNode) && nextNode !== startNode && nextNode !== endNode) {
+ endNode = nextNode;
+ endLine = this.extendEndLine(endNode.sourcepos[1][0] + lineDiff);
+ }
+ }
+ return [startNode, endNode, startLine, endLine];
+ };
+ ToastMark.prototype.parse = function (startPos, endPos, lineDiff) {
+ if (lineDiff === void 0) {
+ lineDiff = 0;
+ }
+ var range = this.getNodeRange(startPos, endPos);
+ var startNode = range[0], endNode = range[1];
+ var startLine = startNode ? Math.min(startNode.sourcepos[0][0], startPos[0]) : startPos[0];
+ var endLine = this.extendEndLine((endNode ? Math.max(endNode.sourcepos[1][0], endPos[0]) : endPos[0]) + lineDiff);
+ var parseResult = this.parseRange.apply(this, this.getRangeWithRefDef(startLine, endLine, startNode, endNode, lineDiff));
+ var newNodes = parseResult.newNodes, extStartNode = parseResult.extStartNode, extEndNode = parseResult.extEndNode;
+ var removedNodeRange = this.getRemovedNodeRange(extStartNode, extEndNode);
+ var nextNode = extEndNode ? extEndNode.next : this.root.firstChild;
+ if (this.referenceDefinition) {
+ this.markDeletedRefMap(extStartNode, extEndNode);
+ this.replaceRangeNodes(extStartNode, extEndNode, newNodes);
+ this.replaceWithNewRefDefState(newNodes);
+ }
+ else {
+ this.replaceRangeNodes(extStartNode, extEndNode, newNodes);
+ }
+ return { nodes: newNodes, removedNodeRange: removedNodeRange, nextNode: nextNode };
+ };
+ ToastMark.prototype.parseRefLink = function () {
+ var _this = this;
+ var result = [];
+ if (!isEmptyObj(this.refMap)) {
+ iterateObject(this.refMap, function (label, value) {
+ if (value.unlinked) {
+ delete _this.refMap[label];
+ }
+ iterateObject(_this.refLinkCandidateMap, function (_, candidate) {
+ var node = candidate.node, refLabel = candidate.refLabel;
+ if (refLabel === label) {
+ result.push(_this.parse(node.sourcepos[0], node.sourcepos[1]));
+ }
+ });
+ });
+ }
+ return result;
+ };
+ ToastMark.prototype.removeUnlinkedCandidate = function () {
+ if (!isEmptyObj(this.refDefCandidateMap)) {
+ [this.refLinkCandidateMap, this.refDefCandidateMap].forEach(function (candidateMap) {
+ iterateObject(candidateMap, function (id) {
+ if (isUnlinked(id)) {
+ delete candidateMap[id];
+ }
+ });
+ });
+ }
+ };
+ ToastMark.prototype.editMarkdown = function (startPos, endPos, newText) {
+ var lineDiff = this.updateLineTexts(startPos, endPos, newText);
+ var parseResult = this.parse(startPos, endPos, lineDiff);
+ var editResult = omit(parseResult, 'nextNode');
+ updateNextLineNumbers(parseResult.nextNode, lineDiff);
+ this.updateRootNodeState();
+ var result = [editResult];
+ if (this.referenceDefinition) {
+ this.removeUnlinkedCandidate();
+ this.replaceWithRefDefCandidate();
+ result = result.concat(this.parseRefLink());
+ }
+ this.trigger('change', result);
+ return result;
+ };
+ ToastMark.prototype.getLineTexts = function () {
+ return this.lineTexts;
+ };
+ ToastMark.prototype.getRootNode = function () {
+ return this.root;
+ };
+ ToastMark.prototype.findNodeAtPosition = function (pos) {
+ var node = findNodeAtPosition(this.root, pos);
+ if (!node || node === this.root) {
+ return null;
+ }
+ return node;
+ };
+ ToastMark.prototype.findFirstNodeAtLine = function (line) {
+ return findFirstNodeAtLine(this.root, line);
+ };
+ ToastMark.prototype.on = function (eventName, callback) {
+ this.eventHandlerMap[eventName].push(callback);
+ };
+ ToastMark.prototype.off = function (eventName, callback) {
+ var handlers = this.eventHandlerMap[eventName];
+ var idx = handlers.indexOf(callback);
+ handlers.splice(idx, 1);
+ };
+ ToastMark.prototype.findNodeById = function (id) {
+ return findNodeById(id);
+ };
+ ToastMark.prototype.removeAllNode = function () {
+ removeAllNode();
+ };
+ return ToastMark;
+}());
+var disallowedTags = [
+ 'title',
+ 'textarea',
+ 'style',
+ 'xmp',
+ 'iframe',
+ 'noembed',
+ 'noframes',
+ 'script',
+ 'plaintext',
+];
+var reDisallowedTag = new RegExp("<(/?(?:" + disallowedTags.join('|') + ")[^>]*>)", 'ig');
+function filterDisallowedTags(str) {
+ if (reDisallowedTag.test(str)) {
+ return str.replace(reDisallowedTag, function (_, group) { return "<" + group; });
+ }
+ return str;
+}
+var baseConvertors = {
+ heading: function (node, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: "h" + node.level,
+ outerNewLine: true,
+ };
+ },
+ text: function (node) {
+ return {
+ type: 'text',
+ content: node.literal,
+ };
+ },
+ softbreak: function (_, _a) {
+ var options = _a.options;
+ return {
+ type: 'html',
+ content: options.softbreak,
+ };
+ },
+ linebreak: function () {
+ return {
+ type: 'html',
+ content: '
\n',
+ };
+ },
+ emph: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'em',
+ };
+ },
+ strong: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'strong',
+ };
+ },
+ paragraph: function (node, _a) {
+ var _b;
+ var entering = _a.entering;
+ var grandparent = (_b = node.parent) === null || _b === void 0 ? void 0 : _b.parent;
+ if (grandparent && grandparent.type === 'list') {
+ if (grandparent.listData.tight) {
+ return null;
+ }
+ }
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'p',
+ outerNewLine: true,
+ };
+ },
+ thematicBreak: function () {
+ return {
+ type: 'openTag',
+ tagName: 'hr',
+ outerNewLine: true,
+ selfClose: true,
+ };
+ },
+ blockQuote: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'blockquote',
+ outerNewLine: true,
+ innerNewLine: true,
+ };
+ },
+ list: function (node, _a) {
+ var entering = _a.entering;
+ var _b = node.listData, type = _b.type, start = _b.start;
+ var tagName = type === 'bullet' ? 'ul' : 'ol';
+ var attributes = {};
+ if (tagName === 'ol' && start !== null && start !== 1) {
+ attributes.start = start.toString();
+ }
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: tagName,
+ attributes: attributes,
+ outerNewLine: true,
+ };
+ },
+ item: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'li',
+ outerNewLine: true,
+ };
+ },
+ htmlInline: function (node, _a) {
+ var options = _a.options;
+ var content = options.tagFilter ? filterDisallowedTags(node.literal) : node.literal;
+ return { type: 'html', content: content };
+ },
+ htmlBlock: function (node, _a) {
+ var options = _a.options;
+ var content = options.tagFilter ? filterDisallowedTags(node.literal) : node.literal;
+ if (options.nodeId) {
+ return [
+ { type: 'openTag', tagName: 'div', outerNewLine: true },
+ { type: 'html', content: content },
+ { type: 'closeTag', tagName: 'div', outerNewLine: true },
+ ];
+ }
+ return { type: 'html', content: content, outerNewLine: true };
+ },
+ code: function (node) {
+ return [
+ { type: 'openTag', tagName: 'code' },
+ { type: 'text', content: node.literal },
+ { type: 'closeTag', tagName: 'code' },
+ ];
+ },
+ codeBlock: function (node) {
+ var infoStr = node.info;
+ var infoWords = infoStr ? infoStr.split(/\s+/) : [];
+ var codeClassNames = [];
+ if (infoWords.length > 0 && infoWords[0].length > 0) {
+ codeClassNames.push("language-" + esm_escapeXml(infoWords[0]));
+ }
+ return [
+ { type: 'openTag', tagName: 'pre', outerNewLine: true },
+ { type: 'openTag', tagName: 'code', classNames: codeClassNames },
+ { type: 'text', content: node.literal },
+ { type: 'closeTag', tagName: 'code' },
+ { type: 'closeTag', tagName: 'pre', outerNewLine: true },
+ ];
+ },
+ link: function (node, _a) {
+ var entering = _a.entering;
+ if (entering) {
+ var _b = node, title = _b.title, destination = _b.destination;
+ return {
+ type: 'openTag',
+ tagName: 'a',
+ attributes: esm_assign({ href: esm_escapeXml(destination) }, (title && { title: esm_escapeXml(title) })),
+ };
+ }
+ return { type: 'closeTag', tagName: 'a' };
+ },
+ image: function (node, _a) {
+ var getChildrenText = _a.getChildrenText, skipChildren = _a.skipChildren;
+ var _b = node, title = _b.title, destination = _b.destination;
+ skipChildren();
+ return {
+ type: 'openTag',
+ tagName: 'img',
+ selfClose: true,
+ attributes: esm_assign({ src: esm_escapeXml(destination), alt: getChildrenText(node) }, (title && { title: esm_escapeXml(title) })),
+ };
+ },
+ customBlock: function (node, context, convertors) {
+ var info = node.info.trim().toLowerCase();
+ var customConvertor = convertors[info];
+ if (customConvertor) {
+ try {
+ return customConvertor(node, context);
+ }
+ catch (e) {
+ console.warn("[@toast-ui/editor] - The error occurred when " + info + " block node was parsed in markdown renderer: " + e);
+ }
+ }
+ return [
+ { type: 'openTag', tagName: 'div', outerNewLine: true },
+ { type: 'text', content: node.literal },
+ { type: 'closeTag', tagName: 'div', outerNewLine: true },
+ ];
+ },
+ frontMatter: function (node) {
+ return [
+ {
+ type: 'openTag',
+ tagName: 'div',
+ outerNewLine: true,
+ // Because front matter is metadata, it should not be render.
+ attributes: { style: 'white-space: pre; display: none;' },
+ },
+ { type: 'text', content: node.literal },
+ { type: 'closeTag', tagName: 'div', outerNewLine: true },
+ ];
+ },
+ customInline: function (node, context, convertors) {
+ var _a = node, info = _a.info, firstChild = _a.firstChild;
+ var nomalizedInfo = info.trim().toLowerCase();
+ var customConvertor = convertors[nomalizedInfo];
+ var entering = context.entering;
+ if (customConvertor) {
+ try {
+ return customConvertor(node, context);
+ }
+ catch (e) {
+ console.warn("[@toast-ui/editor] - The error occurred when " + nomalizedInfo + " inline node was parsed in markdown renderer: " + e);
+ }
+ }
+ return entering
+ ? [
+ { type: 'openTag', tagName: 'span' },
+ { type: 'text', content: "$$" + info + (firstChild ? ' ' : '') },
+ ]
+ : [
+ { type: 'text', content: '$$' },
+ { type: 'closeTag', tagName: 'span' },
+ ];
+ },
+};
+var gfmConvertors = {
+ strike: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'del',
+ };
+ },
+ item: function (node, _a) {
+ var entering = _a.entering;
+ var _b = node.listData, checked = _b.checked, task = _b.task;
+ if (entering) {
+ var itemTag = {
+ type: 'openTag',
+ tagName: 'li',
+ outerNewLine: true,
+ };
+ if (task) {
+ return [
+ itemTag,
+ {
+ type: 'openTag',
+ tagName: 'input',
+ selfClose: true,
+ attributes: esm_assign(esm_assign({}, (checked && { checked: '' })), { disabled: '', type: 'checkbox' }),
+ },
+ {
+ type: 'text',
+ content: ' ',
+ },
+ ];
+ }
+ return itemTag;
+ }
+ return {
+ type: 'closeTag',
+ tagName: 'li',
+ outerNewLine: true,
+ };
+ },
+ table: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'table',
+ outerNewLine: true,
+ };
+ },
+ tableHead: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'thead',
+ outerNewLine: true,
+ };
+ },
+ tableBody: function (_, _a) {
+ var entering = _a.entering;
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ tagName: 'tbody',
+ outerNewLine: true,
+ };
+ },
+ tableRow: function (node, _a) {
+ var entering = _a.entering;
+ if (entering) {
+ return {
+ type: 'openTag',
+ tagName: 'tr',
+ outerNewLine: true,
+ };
+ }
+ var result = [];
+ if (node.lastChild) {
+ var columnLen = node.parent.parent.columns.length;
+ var lastColIdx = node.lastChild.endIdx;
+ for (var i = lastColIdx + 1; i < columnLen; i += 1) {
+ result.push({
+ type: 'openTag',
+ tagName: 'td',
+ outerNewLine: true,
+ }, {
+ type: 'closeTag',
+ tagName: 'td',
+ outerNewLine: true,
+ });
+ }
+ }
+ result.push({
+ type: 'closeTag',
+ tagName: 'tr',
+ outerNewLine: true,
+ });
+ return result;
+ },
+ tableCell: function (node, _a) {
+ var entering = _a.entering;
+ if (node.ignored) {
+ return {
+ type: 'text',
+ content: '',
+ };
+ }
+ var tablePart = node.parent.parent;
+ var tagName = tablePart.type === 'tableHead' ? 'th' : 'td';
+ var table = tablePart.parent;
+ var columnInfo = table.columns[node.startIdx];
+ var attributes = (columnInfo === null || columnInfo === void 0 ? void 0 : columnInfo.align) ? { align: columnInfo.align } : null;
+ if (entering) {
+ return esm_assign({ type: 'openTag', tagName: tagName, outerNewLine: true }, (attributes && { attributes: attributes }));
+ }
+ return {
+ type: 'closeTag',
+ tagName: tagName,
+ outerNewLine: true,
+ };
+ },
+};
+var defaultOptions = {
+ softbreak: '\n',
+ gfm: false,
+ tagFilter: false,
+ nodeId: false,
+};
+function esm_getChildrenText(node) {
+ var buffer = [];
+ var walker = node.walker();
+ var event = null;
+ while ((event = walker.next())) {
+ var node_1 = event.node;
+ if (node_1.type === 'text') {
+ buffer.push(node_1.literal);
+ }
+ }
+ return buffer.join('');
+}
+var Renderer = /** @class */ (function () {
+ function Renderer(customOptions) {
+ this.buffer = [];
+ this.options = esm_assign(esm_assign({}, defaultOptions), customOptions);
+ this.convertors = this.createConvertors();
+ delete this.options.convertors;
+ }
+ Renderer.prototype.createConvertors = function () {
+ var convertors = esm_assign({}, baseConvertors);
+ if (this.options.gfm) {
+ convertors = esm_assign(esm_assign({}, convertors), gfmConvertors);
+ }
+ if (this.options.convertors) {
+ var customConvertors_1 = this.options.convertors;
+ var nodeTypes = Object.keys(customConvertors_1);
+ var defaultConvertors_1 = esm_assign(esm_assign({}, baseConvertors), gfmConvertors);
+ nodeTypes.forEach(function (nodeType) {
+ var orgConvertor = convertors[nodeType];
+ var convertor = customConvertors_1[nodeType];
+ var convertorType = Object.keys(defaultConvertors_1).indexOf(nodeType) === -1
+ ? nodeType.toLowerCase()
+ : nodeType;
+ if (orgConvertor) {
+ convertors[convertorType] = function (node, context, convertors) {
+ context.origin = function () { return orgConvertor(node, context, convertors); };
+ return convertor(node, context);
+ };
+ }
+ else {
+ convertors[convertorType] = convertor;
+ }
+ });
+ }
+ return convertors;
+ };
+ Renderer.prototype.getConvertors = function () {
+ return this.convertors;
+ };
+ Renderer.prototype.getOptions = function () {
+ return this.options;
+ };
+ Renderer.prototype.render = function (rootNode) {
+ var _this = this;
+ this.buffer = [];
+ var walker = rootNode.walker();
+ var event = null;
+ var _loop_1 = function () {
+ var node = event.node, entering = event.entering;
+ var convertor = this_1.convertors[node.type];
+ if (!convertor) {
+ return "continue";
+ }
+ var skipped = false;
+ var context = {
+ entering: entering,
+ leaf: !esm_isContainer(node),
+ options: this_1.options,
+ getChildrenText: esm_getChildrenText,
+ skipChildren: function () {
+ skipped = true;
+ },
+ };
+ var converted = isCustomBlock(node) || isCustomInline(node)
+ ? convertor(node, context, this_1.convertors)
+ : convertor(node, context);
+ if (converted) {
+ var htmlNodes = Array.isArray(converted) ? converted : [converted];
+ htmlNodes.forEach(function (htmlNode, index) {
+ if (htmlNode.type === 'openTag' && _this.options.nodeId && index === 0) {
+ if (!htmlNode.attributes) {
+ htmlNode.attributes = {};
+ }
+ htmlNode.attributes['data-nodeid'] = String(node.id);
+ }
+ _this.renderHTMLNode(htmlNode);
+ });
+ if (skipped) {
+ walker.resumeAt(node, false);
+ walker.next();
+ }
+ }
+ };
+ var this_1 = this;
+ while ((event = walker.next())) {
+ _loop_1();
+ }
+ this.addNewLine();
+ return this.buffer.join('');
+ };
+ Renderer.prototype.renderHTMLNode = function (node) {
+ switch (node.type) {
+ case 'openTag':
+ case 'closeTag':
+ this.renderElementNode(node);
+ break;
+ case 'text':
+ this.renderTextNode(node);
+ break;
+ case 'html':
+ this.renderRawHtmlNode(node);
+ break;
+ // no-default-case
+ }
+ };
+ Renderer.prototype.generateOpenTagString = function (node) {
+ var _this = this;
+ var tagName = node.tagName, classNames = node.classNames, attributes = node.attributes;
+ this.buffer.push("<" + tagName);
+ if (classNames && classNames.length > 0) {
+ this.buffer.push(" class=\"" + classNames.join(' ') + "\"");
+ }
+ if (attributes) {
+ Object.keys(attributes).forEach(function (attrName) {
+ var attrValue = attributes[attrName];
+ _this.buffer.push(" " + attrName + "=\"" + attrValue + "\"");
+ });
+ }
+ if (node.selfClose) {
+ this.buffer.push(' /');
+ }
+ this.buffer.push('>');
+ };
+ Renderer.prototype.generateCloseTagString = function (_a) {
+ var tagName = _a.tagName;
+ this.buffer.push("");
+ };
+ Renderer.prototype.addNewLine = function () {
+ if (this.buffer.length && esm_last(esm_last(this.buffer)) !== '\n') {
+ this.buffer.push('\n');
+ }
+ };
+ Renderer.prototype.addOuterNewLine = function (node) {
+ if (node.outerNewLine) {
+ this.addNewLine();
+ }
+ };
+ Renderer.prototype.addInnerNewLine = function (node) {
+ if (node.innerNewLine) {
+ this.addNewLine();
+ }
+ };
+ Renderer.prototype.renderTextNode = function (node) {
+ this.buffer.push(esm_escapeXml(node.content));
+ };
+ Renderer.prototype.renderRawHtmlNode = function (node) {
+ this.addOuterNewLine(node);
+ this.buffer.push(node.content);
+ this.addOuterNewLine(node);
+ };
+ Renderer.prototype.renderElementNode = function (node) {
+ if (node.type === 'openTag') {
+ this.addOuterNewLine(node);
+ this.generateOpenTagString(node);
+ if (node.selfClose) {
+ this.addOuterNewLine(node);
+ }
+ else {
+ this.addInnerNewLine(node);
+ }
+ }
+ else {
+ this.addInnerNewLine(node);
+ this.generateCloseTagString(node);
+ this.addOuterNewLine(node);
+ }
+ };
+ return Renderer;
+}());
+
+
+// EXTERNAL MODULE: ../../node_modules/dompurify/dist/purify.js
+var purify = __webpack_require__(368);
+var purify_default = /*#__PURE__*/__webpack_require__.n(purify);
+;// CONCATENATED MODULE: ./src/sanitizer/htmlSanitizer.ts
+
+
+
+var CAN_BE_WHITE_TAG_LIST = ['iframe', 'embed'];
+var whiteTagList = [];
+function registerTagWhitelistIfPossible(tagName) {
+ if (common_includes(CAN_BE_WHITE_TAG_LIST, tagName)) {
+ whiteTagList.push(tagName.toLowerCase());
+ }
+}
+function sanitizeHTML(html, options) {
+ return purify_default().sanitize(html, __assign({ ADD_TAGS: whiteTagList, ADD_ATTR: ['rel', 'target', 'hreflang', 'type'], FORBID_TAGS: [
+ 'input',
+ 'script',
+ 'textarea',
+ 'form',
+ 'button',
+ 'select',
+ 'meta',
+ 'style',
+ 'link',
+ 'title',
+ 'object',
+ 'base',
+ ] }, options));
+}
+
+;// CONCATENATED MODULE: ./src/wysiwyg/nodes/html.ts
+
+
+
+
+function getChildrenHTML(node, typeName) {
+ return node
+ .literal.replace(new RegExp("(<\\s*" + typeName + "[^>]*>)|(])", 'ig'), '')
+ .trim();
+}
+function getHTMLAttrsByHTMLString(html) {
+ html = html.match(reHTMLTag)[0];
+ var attrs = html.match(new RegExp(ATTRIBUTE, 'g'));
+ return attrs
+ ? attrs.reduce(function (acc, attr) {
+ var _a = attr.trim().split('='), name = _a[0], values = _a.slice(1);
+ if (values.length) {
+ acc[name] = values.join('=').replace(/'|"/g, '').trim();
+ }
+ return acc;
+ }, {})
+ : {};
+}
+function getHTMLAttrs(dom) {
+ return toArray_default()(dom.attributes).reduce(function (acc, attr) {
+ acc[attr.nodeName] = attr.nodeValue;
+ return acc;
+ }, {});
+}
+function sanitizeDOM(node, typeName, sanitizer, wwToDOMAdaptor) {
+ var dom = wwToDOMAdaptor.getToDOMNode(typeName)(node);
+ var html = sanitizer(dom.outerHTML);
+ var container = document.createElement('div');
+ container.innerHTML = html;
+ dom = container.firstChild;
+ var htmlAttrs = getHTMLAttrs(dom);
+ return { dom: dom, htmlAttrs: htmlAttrs };
+}
+var schemaFactory = {
+ htmlBlock: function (typeName, sanitizeHTML, wwToDOMAdaptor) {
+ return {
+ atom: true,
+ content: 'block+',
+ group: 'block',
+ attrs: {
+ htmlAttrs: { default: {} },
+ childrenHTML: { default: '' },
+ htmlBlock: { default: true },
+ },
+ parseDOM: [
+ {
+ tag: typeName,
+ getAttrs: function (dom) {
+ return {
+ htmlAttrs: getHTMLAttrs(dom),
+ childrenHTML: dom.innerHTML,
+ };
+ },
+ },
+ ],
+ toDOM: function (node) {
+ var _a = sanitizeDOM(node, typeName, sanitizeHTML, wwToDOMAdaptor), dom = _a.dom, htmlAttrs = _a.htmlAttrs;
+ htmlAttrs.class = htmlAttrs.class ? htmlAttrs.class + " html-block" : 'html-block';
+ return __spreadArray([typeName, htmlAttrs], toArray_default()(dom.childNodes));
+ },
+ };
+ },
+ htmlInline: function (typeName, sanitizeHTML, wwToDOMAdaptor) {
+ return {
+ attrs: {
+ htmlAttrs: { default: {} },
+ htmlInline: { default: true },
+ },
+ parseDOM: [
+ {
+ tag: typeName,
+ getAttrs: function (dom) {
+ return {
+ htmlAttrs: getHTMLAttrs(dom),
+ };
+ },
+ },
+ ],
+ toDOM: function (node) {
+ var htmlAttrs = sanitizeDOM(node, typeName, sanitizeHTML, wwToDOMAdaptor).htmlAttrs;
+ return [typeName, htmlAttrs, 0];
+ },
+ };
+ },
+};
+function createHTMLSchemaMap(convertorMap, sanitizeHTML, wwToDOMAdaptor) {
+ var htmlSchemaMap = { nodes: {}, marks: {} };
+ ['htmlBlock', 'htmlInline'].forEach(function (htmlType) {
+ if (convertorMap[htmlType]) {
+ Object.keys(convertorMap[htmlType]).forEach(function (type) {
+ var targetType = htmlType === 'htmlBlock' ? 'nodes' : 'marks';
+ // register tag white list for preventing to remove the html in sanitizer
+ registerTagWhitelistIfPossible(type);
+ htmlSchemaMap[targetType][type] = schemaFactory[htmlType](type, sanitizeHTML, wwToDOMAdaptor);
+ });
+ }
+ });
+ return htmlSchemaMap;
+}
+
+;// CONCATENATED MODULE: ./src/markdown/htmlRenderConvertors.ts
+
+
+
+
+
+
+var reCloseTag = /^\s*<\s*\//;
+var htmlRenderConvertors_baseConvertors = {
+ paragraph: function (_, _a) {
+ var entering = _a.entering, origin = _a.origin, options = _a.options;
+ if (options.nodeId) {
+ return {
+ type: entering ? 'openTag' : 'closeTag',
+ outerNewLine: true,
+ tagName: 'p',
+ };
+ }
+ return origin();
+ },
+ softbreak: function (node) {
+ var isPrevNodeHTML = node.prev && node.prev.type === 'htmlInline';
+ var isPrevBR = isPrevNodeHTML && /
/.test(node.prev.literal);
+ var content = isPrevBR ? '\n' : '
\n';
+ return { type: 'html', content: content };
+ },
+ item: function (node, _a) {
+ var entering = _a.entering;
+ if (entering) {
+ var attributes = {};
+ var classNames = [];
+ if (node.listData.task) {
+ attributes['data-task'] = '';
+ classNames.push('task-list-item');
+ if (node.listData.checked) {
+ classNames.push('checked');
+ attributes['data-task-checked'] = '';
+ }
+ }
+ return {
+ type: 'openTag',
+ tagName: 'li',
+ classNames: classNames,
+ attributes: attributes,
+ outerNewLine: true,
+ };
+ }
+ return {
+ type: 'closeTag',
+ tagName: 'li',
+ outerNewLine: true,
+ };
+ },
+ code: function (node) {
+ var attributes = { 'data-backticks': String(node.tickCount) };
+ return [
+ { type: 'openTag', tagName: 'code', attributes: attributes },
+ { type: 'text', content: node.literal },
+ { type: 'closeTag', tagName: 'code' },
+ ];
+ },
+ codeBlock: function (node) {
+ var _a = node, fenceLength = _a.fenceLength, info = _a.info;
+ var infoWords = info ? info.split(/\s+/) : [];
+ var preClasses = [];
+ var codeAttrs = {};
+ if (fenceLength > 3) {
+ codeAttrs['data-backticks'] = fenceLength;
+ }
+ if (infoWords.length > 0 && infoWords[0].length > 0) {
+ var lang = infoWords[0];
+ preClasses.push("lang-" + lang);
+ codeAttrs['data-language'] = lang;
+ }
+ return [
+ { type: 'openTag', tagName: 'pre', classNames: preClasses },
+ { type: 'openTag', tagName: 'code', attributes: codeAttrs },
+ { type: 'text', content: node.literal },
+ { type: 'closeTag', tagName: 'code' },
+ { type: 'closeTag', tagName: 'pre' },
+ ];
+ },
+ customInline: function (node, _a) {
+ var origin = _a.origin, entering = _a.entering, skipChildren = _a.skipChildren;
+ var info = node.info;
+ if (info.indexOf('widget') !== -1 && entering) {
+ skipChildren();
+ var content = getWidgetContent(node);
+ var htmlInline = widgetToDOM(info, content).outerHTML;
+ return [
+ { type: 'openTag', tagName: 'span', classNames: ['tui-widget'] },
+ { type: 'html', content: htmlInline },
+ { type: 'closeTag', tagName: 'span' },
+ ];
+ }
+ return origin();
+ },
+};
+function getHTMLRenderConvertors(linkAttributes, customConvertors) {
+ var convertors = __assign({}, htmlRenderConvertors_baseConvertors);
+ if (linkAttributes) {
+ convertors.link = function (_, _a) {
+ var entering = _a.entering, origin = _a.origin;
+ var result = origin();
+ if (entering) {
+ result.attributes = __assign(__assign({}, result.attributes), linkAttributes);
+ }
+ return result;
+ };
+ }
+ if (customConvertors) {
+ Object.keys(customConvertors).forEach(function (nodeType) {
+ var orgConvertor = convertors[nodeType];
+ var customConvertor = customConvertors[nodeType];
+ if (orgConvertor && isFunction_default()(customConvertor)) {
+ convertors[nodeType] = function (node, context) {
+ var newContext = __assign({}, context);
+ newContext.origin = function () { return orgConvertor(node, context); };
+ return customConvertor(node, newContext);
+ };
+ }
+ else if (common_includes(['htmlBlock', 'htmlInline'], nodeType) && !isFunction_default()(customConvertor)) {
+ convertors[nodeType] = function (node, context) {
+ var matched = node.literal.match(reHTMLTag);
+ if (matched) {
+ var rootHTML = matched[0], openTagName = matched[1], closeTagName = matched[3];
+ var typeName = (openTagName || closeTagName).toLowerCase();
+ var htmlConvertor = customConvertor[typeName];
+ var childrenHTML = getChildrenHTML(node, typeName);
+ if (htmlConvertor) {
+ // copy for preventing to overwrite the originial property
+ var newNode = __assign({}, node);
+ newNode.attrs = getHTMLAttrsByHTMLString(rootHTML);
+ newNode.childrenHTML = childrenHTML;
+ newNode.type = typeName;
+ context.entering = !reCloseTag.test(node.literal);
+ return htmlConvertor(newNode, context);
+ }
+ }
+ return context.origin();
+ };
+ }
+ else {
+ convertors[nodeType] = customConvertor;
+ }
+ });
+ }
+ return convertors;
+}
+
+;// CONCATENATED MODULE: ./src/markdown/scroll/dom.ts
+
+
+var nestableTypes = ['list', 'item', 'blockQuote'];
+var nestableTagNames = ['UL', 'OL', 'BLOCKQUOTE'];
+function isBlankLine(doc, index) {
+ var _a;
+ var pmNode = doc.child(index);
+ return !pmNode.childCount || (pmNode.childCount === 1 && !((_a = pmNode.firstChild.text) === null || _a === void 0 ? void 0 : _a.trim()));
+}
+function getEditorRangeHeightInfo(doc, mdNode, children) {
+ var start = getMdStartLine(mdNode) - 1;
+ var end = getMdEndLine(mdNode) - 1;
+ var rect = children[start].getBoundingClientRect();
+ var height = children[end].offsetTop -
+ children[start].offsetTop +
+ children[end].clientHeight;
+ return {
+ height: height <= 0
+ ? children[start].clientHeight
+ : height + getBlankLinesHeight(doc, children, Math.min(end + 1, doc.childCount - 1)),
+ rect: rect,
+ };
+}
+function getBlankLinesHeight(doc, children, start) {
+ var end = doc.childCount - 1;
+ var height = 0;
+ while (start <= end && isBlankLine(doc, start)) {
+ height += children[start].clientHeight;
+ start += 1;
+ }
+ return height;
+}
+function findAncestorHavingId(el, root) {
+ while (!el.getAttribute('data-nodeid') && el.parentElement !== root) {
+ el = el.parentElement;
+ }
+ return el;
+}
+function getTotalOffsetTop(el, root) {
+ var offsetTop = 0;
+ while (el && el !== root) {
+ if (!common_includes(nestableTagNames, el.tagName)) {
+ offsetTop += el.offsetTop;
+ }
+ if (el.offsetParent === root.offsetParent) {
+ break;
+ }
+ el = el.parentElement;
+ }
+ return offsetTop;
+}
+function findAdjacentElementToScrollTop(scrollTop, root) {
+ var el = root;
+ var prev = null;
+ while (el) {
+ var firstElementChild = el.firstElementChild;
+ if (!firstElementChild) {
+ break;
+ }
+ var lastSibling = findLastSiblingElementToScrollTop(firstElementChild, scrollTop, getTotalOffsetTop(el, root));
+ prev = el;
+ el = lastSibling;
+ }
+ var adjacentEl = el || prev;
+ return adjacentEl === root ? null : adjacentEl;
+}
+function findLastSiblingElementToScrollTop(el, scrollTop, offsetTop) {
+ if (el && scrollTop > offsetTop + el.offsetTop) {
+ return (findLastSiblingElementToScrollTop(el.nextElementSibling, scrollTop, offsetTop) || el);
+ }
+ return null;
+}
+function getAdditionalPos(scrollTop, offsetTop, height, targetNodeHeight) {
+ var ratio = Math.min((scrollTop - offsetTop) / height, 1);
+ return ratio * targetNodeHeight;
+}
+function getParentNodeObj(previewContent, mdNode) {
+ var el = previewContent.querySelector("[data-nodeid=\"" + mdNode.id + "\"]");
+ while (!el || isStyledInlineNode(mdNode)) {
+ mdNode = mdNode.parent;
+ el = previewContent.querySelector("[data-nodeid=\"" + mdNode.id + "\"]");
+ }
+ return getNonNestableNodeObj({ mdNode: mdNode, el: el });
+}
+function getNonNestableNodeObj(_a) {
+ var mdNode = _a.mdNode, el = _a.el;
+ while ((common_includes(nestableTypes, mdNode.type) || mdNode.type === 'table') && mdNode.firstChild) {
+ mdNode = mdNode.firstChild;
+ el = el.firstElementChild;
+ }
+ return { mdNode: mdNode, el: el };
+}
+
+;// CONCATENATED MODULE: ./src/markdown/scroll/offset.ts
+
+
+var offsetInfoMap = {};
+function setHeight(id, height) {
+ offsetInfoMap[id] = offsetInfoMap[id] || {};
+ offsetInfoMap[id].height = height;
+}
+function setOffsetTop(id, offsetTop) {
+ offsetInfoMap[id] = offsetInfoMap[id] || {};
+ offsetInfoMap[id].offsetTop = offsetTop;
+}
+function getHeight(id) {
+ return offsetInfoMap[id] && offsetInfoMap[id].height;
+}
+function getOffsetTop(id) {
+ return offsetInfoMap[id] && offsetInfoMap[id].offsetTop;
+}
+function removeOffsetInfoByNode(node) {
+ if (node) {
+ delete offsetInfoMap[Number(node.getAttribute('data-nodeid'))];
+ toArray_default()(node.children).forEach(function (child) {
+ removeOffsetInfoByNode(child);
+ });
+ }
+}
+function getAndSaveOffsetInfo(node, root, mdNodeId) {
+ var cachedHeight = getHeight(mdNodeId);
+ var cachedTop = getOffsetTop(mdNodeId);
+ var nodeHeight = cachedHeight || node.clientHeight;
+ var offsetTop = cachedTop || getTotalOffsetTop(node, root) || node.offsetTop;
+ if (!cachedHeight) {
+ setHeight(mdNodeId, nodeHeight);
+ }
+ if (!cachedTop) {
+ setOffsetTop(mdNodeId, offsetTop);
+ }
+ return { nodeHeight: nodeHeight, offsetTop: offsetTop };
+}
+
+;// CONCATENATED MODULE: ./src/markdown/mdPreview.ts
+
+
+
+
+
+
+
+
+
+
+
+var CLASS_HIGHLIGHT = cls('md-preview-highlight');
+function findTableCell(tableRow, chOffset) {
+ var cell = tableRow.firstChild;
+ while (cell && cell.next) {
+ if (getMdStartCh(cell.next) > chOffset + 1) {
+ break;
+ }
+ cell = cell.next;
+ }
+ return cell;
+}
+/**
+ * Class Markdown Preview
+ * @param {HTMLElement} el - base element
+ * @param {eventEmitter} eventEmitter - event manager
+ * @param {object} options
+ * @param {boolean} options.isViewer - true for view-only mode
+ * @param {boolean} options.highlight - true for using live-highlight feature
+ * @param {object} opitons.linkAttributes - attributes for link element
+ * @param {object} opitons.customHTMLRenderer - map of custom HTML render functions
+ *
+ * @ignore
+ */
+var MarkdownPreview = /** @class */ (function () {
+ function MarkdownPreview(eventEmitter, options) {
+ var el = document.createElement('div');
+ this.el = el;
+ this.eventEmitter = eventEmitter;
+ this.isViewer = !!options.isViewer;
+ this.el.className = cls('md-preview');
+ var linkAttributes = options.linkAttributes, customHTMLRenderer = options.customHTMLRenderer, sanitizer = options.sanitizer, _a = options.highlight, highlight = _a === void 0 ? false : _a;
+ this.renderer = new Renderer({
+ gfm: true,
+ nodeId: true,
+ convertors: getHTMLRenderConvertors(linkAttributes, customHTMLRenderer),
+ });
+ this.cursorNodeId = null;
+ this.sanitizer = sanitizer;
+ this.initEvent(highlight);
+ this.initContentSection();
+ // To prevent overflowing contents in the viewer
+ if (this.isViewer) {
+ this.previewContent.style.overflowWrap = 'break-word';
+ }
+ }
+ MarkdownPreview.prototype.initContentSection = function () {
+ this.previewContent = createElementWith("");
+ if (!this.isViewer) {
+ this.el.appendChild(this.previewContent);
+ }
+ };
+ MarkdownPreview.prototype.toggleActive = function (active) {
+ toggleClass(this.el, 'active', active);
+ };
+ MarkdownPreview.prototype.initEvent = function (highlight) {
+ var _this = this;
+ this.eventEmitter.listen('updatePreview', this.update.bind(this));
+ if (this.isViewer) {
+ return;
+ }
+ if (highlight) {
+ this.eventEmitter.listen('changeToolbarState', function (_a) {
+ var mdNode = _a.mdNode, cursorPos = _a.cursorPos;
+ _this.updateCursorNode(mdNode, cursorPos);
+ });
+ this.eventEmitter.listen('blur', function () {
+ _this.removeHighlight();
+ });
+ }
+ on_default()(this.el, 'scroll', function (event) {
+ _this.eventEmitter.emit('scroll', 'preview', findAdjacentElementToScrollTop(event.target.scrollTop, _this.previewContent));
+ });
+ this.eventEmitter.listen('changePreviewTabPreview', function () { return _this.toggleActive(true); });
+ this.eventEmitter.listen('changePreviewTabWrite', function () { return _this.toggleActive(false); });
+ };
+ MarkdownPreview.prototype.removeHighlight = function () {
+ if (this.cursorNodeId) {
+ var currentEl = this.getElementByNodeId(this.cursorNodeId);
+ if (currentEl) {
+ removeClass_default()(currentEl, CLASS_HIGHLIGHT);
+ }
+ }
+ };
+ MarkdownPreview.prototype.updateCursorNode = function (cursorNode, cursorPos) {
+ if (cursorNode) {
+ cursorNode = findClosestNode(cursorNode, function (mdNode) { return !isInlineNode(mdNode); });
+ if (cursorNode.type === 'tableRow') {
+ cursorNode = findTableCell(cursorNode, cursorPos[1]);
+ }
+ else if (cursorNode.type === 'tableBody') {
+ // empty line next to table
+ cursorNode = null;
+ }
+ }
+ var cursorNodeId = cursorNode ? cursorNode.id : null;
+ if (this.cursorNodeId === cursorNodeId) {
+ return;
+ }
+ var oldEL = this.getElementByNodeId(this.cursorNodeId);
+ var newEL = this.getElementByNodeId(cursorNodeId);
+ if (oldEL) {
+ removeClass_default()(oldEL, CLASS_HIGHLIGHT);
+ }
+ if (newEL) {
+ addClass_default()(newEL, CLASS_HIGHLIGHT);
+ }
+ this.cursorNodeId = cursorNodeId;
+ };
+ MarkdownPreview.prototype.getElementByNodeId = function (nodeId) {
+ return nodeId
+ ? this.previewContent.querySelector("[data-nodeid=\"" + nodeId + "\"]")
+ : null;
+ };
+ MarkdownPreview.prototype.update = function (changed) {
+ var _this = this;
+ changed.forEach(function (editResult) { return _this.replaceRangeNodes(editResult); });
+ this.eventEmitter.emit('afterPreviewRender', this);
+ };
+ MarkdownPreview.prototype.replaceRangeNodes = function (editResult) {
+ var _this = this;
+ var nodes = editResult.nodes, removedNodeRange = editResult.removedNodeRange;
+ var contentEl = this.previewContent;
+ var newHtml = this.eventEmitter.emitReduce('beforePreviewRender', this.sanitizer(nodes.map(function (node) { return _this.renderer.render(node); }).join('')));
+ if (!removedNodeRange) {
+ contentEl.insertAdjacentHTML('afterbegin', newHtml);
+ }
+ else {
+ var _a = removedNodeRange.id, startNodeId = _a[0], endNodeId = _a[1];
+ var startEl = this.getElementByNodeId(startNodeId);
+ var endEl = this.getElementByNodeId(endNodeId);
+ if (startEl) {
+ startEl.insertAdjacentHTML('beforebegin', newHtml);
+ var el = startEl;
+ while (el && el !== endEl) {
+ var nextEl = el.nextElementSibling;
+ removeNode(el);
+ removeOffsetInfoByNode(el);
+ el = nextEl;
+ }
+ if (el === null || el === void 0 ? void 0 : el.parentNode) {
+ removeNode(el);
+ removeOffsetInfoByNode(el);
+ }
+ }
+ }
+ };
+ MarkdownPreview.prototype.getRenderer = function () {
+ return this.renderer;
+ };
+ MarkdownPreview.prototype.destroy = function () {
+ off_default()(this.el, 'scroll');
+ this.el = null;
+ };
+ MarkdownPreview.prototype.getElement = function () {
+ return this.el;
+ };
+ MarkdownPreview.prototype.getHTML = function () {
+ return removeProseMirrorHackNodes(this.previewContent.innerHTML);
+ };
+ MarkdownPreview.prototype.setHTML = function (html) {
+ this.previewContent.innerHTML = html;
+ };
+ MarkdownPreview.prototype.setHeight = function (height) {
+ css_default()(this.el, { height: height + "px" });
+ };
+ MarkdownPreview.prototype.setMinHeight = function (minHeight) {
+ css_default()(this.el, { minHeight: minHeight + "px" });
+ };
+ return MarkdownPreview;
+}());
+/* harmony default export */ var mdPreview = (MarkdownPreview);
+
+;// CONCATENATED MODULE: ./src/wysiwyg/helper/node.ts
+
+
+function findNodeBy(pos, condition) {
+ var depth = pos.depth;
+ while (depth) {
+ var node = pos.node(depth);
+ if (condition(node, depth)) {
+ return {
+ node: node,
+ depth: depth,
+ offset: depth > 0 ? pos.before(depth) : 0,
+ };
+ }
+ depth -= 1;
+ }
+ return null;
+}
+function node_isListNode(_a) {
+ var type = _a.type;
+ return type.name === 'bulletList' || type.name === 'orderedList';
+}
+function isInListNode(pos) {
+ return !!findNodeBy(pos, function (_a) {
+ var type = _a.type;
+ return type.name === 'listItem' || type.name === 'bulletList' || type.name === 'orderedList';
+ });
+}
+function isInTableNode(pos) {
+ return !!findNodeBy(pos, function (_a) {
+ var type = _a.type;
+ return type.name === 'tableHeadCell' || type.name === 'tableBodyCell';
+ });
+}
+function findListItem(pos) {
+ return findNodeBy(pos, function (_a) {
+ var type = _a.type;
+ return type.name === 'listItem';
+ });
+}
+function createDOMInfoParsedRawHTML(tag) {
+ return {
+ tag: tag,
+ getAttrs: function (dom) {
+ var rawHTML = dom.getAttribute('data-raw-html');
+ return __assign({}, (rawHTML && { rawHTML: rawHTML }));
+ },
+ };
+}
+function createCellAttrs(attrs) {
+ return Object.keys(attrs).reduce(function (acc, attrName) {
+ if (attrName !== 'rawHTML' && attrs[attrName]) {
+ attrName = attrName === 'className' ? 'class' : attrName;
+ acc[attrName] = attrs[attrName];
+ }
+ return acc;
+ }, {});
+}
+function createParsedCellDOM(tag) {
+ return {
+ tag: tag,
+ getAttrs: function (dom) {
+ return ['rawHTML', 'colspan', 'rowspan', 'extended'].reduce(function (acc, attrName) {
+ var attrNameInDOM = attrName === 'rawHTML' ? 'data-raw-html' : attrName;
+ var attrValue = dom.getAttribute(attrNameInDOM);
+ if (attrValue) {
+ acc[attrName] = common_includes(['rawHTML', 'extended'], attrName)
+ ? attrValue
+ : Number(attrValue);
+ }
+ return acc;
+ }, {});
+ },
+ };
+}
+function getDefaultCustomAttrs() {
+ return {
+ htmlAttrs: { default: null },
+ classNames: { default: null },
+ };
+}
+function getCustomAttrs(attrs) {
+ var htmlAttrs = attrs.htmlAttrs, classNames = attrs.classNames;
+ return __assign(__assign({}, htmlAttrs), { class: classNames ? classNames.join(' ') : null });
+}
+
+;// CONCATENATED MODULE: ./src/wysiwyg/command/list.ts
+
+
+
+
+function list_findWrappingOutside(range, type) {
+ var parent = range.parent, startIndex = range.startIndex, endIndex = range.endIndex;
+ var around = parent.contentMatchAt(startIndex).findWrapping(type);
+ if (around) {
+ var outer = around.length ? around[0] : type;
+ return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null;
+ }
+ return null;
+}
+function list_findWrappingInside(range, type) {
+ var parent = range.parent, startIndex = range.startIndex, endIndex = range.endIndex;
+ var inner = parent.child(startIndex);
+ var inside = type.contentMatch.findWrapping(inner.type);
+ if (inside) {
+ var lastType = inside.length ? inside[inside.length - 1] : type;
+ var innerMatch = lastType.contentMatch;
+ for (var i = startIndex; innerMatch && i < endIndex; i += 1) {
+ innerMatch = innerMatch.matchType(parent.child(i).type);
+ }
+ if (innerMatch && innerMatch.validEnd) {
+ return inside;
+ }
+ }
+ return null;
+}
+function findWrappers(range, innerRange, nodeType, attrs) {
+ var around = list_findWrappingOutside(range, nodeType);
+ var inner = list_findWrappingInside(innerRange, nodeType);
+ if (around && inner) {
+ var aroundNodes = around.map(function (type) {
+ return { type: type };
+ });
+ var innerNodes = inner.map(function (type) {
+ return { type: type, attrs: attrs };
+ });
+ return aroundNodes.concat({ type: nodeType }).concat(innerNodes);
+ }
+ return null;
+}
+function wrapInList(tr, _a, wrappers, joinBefore, list) {
+ var start = _a.start, end = _a.end, startIndex = _a.startIndex, endIndex = _a.endIndex, parent = _a.parent;
+ var content = Fragment.empty;
+ for (var i = wrappers.length - 1; i >= 0; i -= 1) {
+ content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
+ }
+ tr.step(new ReplaceAroundStep(start - (joinBefore ? 2 : 0), end, start, end, new Slice(content, 0, 0), wrappers.length, true));
+ var foundListIndex = 0;
+ for (var i = 0; i < wrappers.length; i += 1) {
+ if (wrappers[i].type === list) {
+ foundListIndex = i + 1;
+ break;
+ }
+ }
+ var splitDepth = wrappers.length - foundListIndex;
+ var splitPos = start + wrappers.length - (joinBefore ? 2 : 0);
+ for (var i = startIndex, len = endIndex; i < len; i += 1) {
+ var first = i === startIndex;
+ if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
+ tr.split(splitPos, splitDepth);
+ splitPos += splitDepth * 2;
+ }
+ splitPos += parent.child(i).nodeSize;
+ }
+ return tr;
+}
+function changeToList(tr, range, list, attrs) {
+ var $from = range.$from, $to = range.$to, depth = range.depth;
+ var outerRange = range;
+ var joinBefore = false;
+ if (depth >= 2 &&
+ $from.node(depth - 1).type.compatibleContent(list) &&
+ range.startIndex === 0 &&
+ $from.index(depth - 1)) {
+ var start = tr.doc.resolve(range.start - 2);
+ outerRange = new NodeRange(start, start, depth);
+ if (range.endIndex < range.parent.childCount) {
+ range = new NodeRange($from, tr.doc.resolve($to.end(depth)), depth);
+ }
+ joinBefore = true;
+ }
+ var wrappers = findWrappers(outerRange, range, list, attrs);
+ if (wrappers) {
+ return wrapInList(tr, range, wrappers, joinBefore, list);
+ }
+ return tr;
+}
+function getBeforeLineListItem(doc, offset) {
+ var endListItemPos = doc.resolve(offset);
+ while (endListItemPos.node().type.name !== 'paragraph') {
+ offset -= 2; // The position value of