https://www.kcl.ac.uk/_GhbZtw_8fe3d6e8-6c75-4fc9-88ef-46b7f2723b06…/legacy/js/3133.2318bd547603a1feeff7.js

454        definitionLabelString: onexitdefinitionlabelstring,
455        definitionTitleString: onexitdefinitiontitlestring,
456        emphasis: closer(),
457        hardBreakEscape: closer(onexithardbreak),
458        hardBreakTrailing: closer(onexithardbreak),
459        htmlFlow: closer(onexithtmlflow),
460        htmlFlowData: onexitdata,
461        htmlText: closer(onexithtmltext),
462        htmlTextData: onexitdata,
463        image: closer(onexitimage),
464        label: onexitlabel,
465        labelText: onexitlabeltext,
466        lineEnding: onexitlineending,
467        link: closer(onexitlink),
468        listItem: closer(),
469        listOrdered: closer(),
470        listUnordered: closer(),
471        paragraph: closer(),
472        referenceString: onexitreferencestring,
473        resourceDestinationString: onexitresourcedestinationstring,
474        resourceTitleString: onexitresourcetitlestring,
475        resource: onexitresource,
476        setextHeading: closer(onexitsetextheading),
477        setextHeadingLineSequence: onexitsetextheadinglinesequence,
478        setextHeadingText: onexitsetextheadingtext,
479        strong: closer(),
480        thematicBreak: closer()
481      }
482    },
483    settings.mdastExtensions || []
484  );
485  var data = {};
486  return compile;
487  function compile(events) {
488    var tree = { type: "root", children: [] };
489    var stack = [tree];
490    var tokenStack = [];
491    var listStack = [];
492    var index = -1;
493    var handler;
494    var listStart;
495    var context = {
496      stack,
497      tokenStack,
498      config,
499      enter,
500      exit,
501      buffer,
502      resume,
503      setData,
504      getData
505    };
506    while (++index < events.length) {
507      if (events[index][1].type === "listOrdered" || events[index][1].type === "listUnordered") {
508        if (events[index][0] === "enter") {
509          listStack.push(index);
510        } else {
511          listStart = listStack.pop(index);
512          index = prepareList(events, listStart, index);
513        }
514      }
515    }
516    index = -1;
517    while (++index < events.length) {
518      handler = config[events[index][0]];
519      if (own.call(handler, events[index][1].type)) {
520        handler[events[index][1].type].call(
521          assign({ sliceSerialize: events[index][2].sliceSerialize }, context),
522          events[index][1]
523        );
524      }
525    }
526    if (tokenStack.length) {
527      throw new Error(
528        "Cannot close document, a token (`" + tokenStack[tokenStack.length - 1].type + "`, " + stringifyPosition({
529          start: tokenStack[tokenStack.length - 1].start,
530          end: tokenStack[tokenStack.length - 1].end
531        }) + ") is still open"
532      );
533    }
534    tree.position = {
535      start: point(
536        events.length ? events[0][1].start : { line: 1, column: 1, offset: 0 }
537      ),
538      end: point(
539        events.length ? events[events.length - 2][1].end : { line: 1, column: 1, offset: 0 }
540      )
541    };
542    index = -1;
543    while (++index < config.transforms.length) {
544      tree = config.transforms[index](tree) || tree;
545    }
546    return tree;
547  }
548  function prepareList(events, start, length) {
549    var index = start - 1;
550    var containerBalance = -1;
551    var listSpread = false;
552    var listItem2;
553    var tailIndex;
554    var lineIndex;
555    var tailEvent;
556    var event;
557    var firstBlankLineIndex;
558    var atMarker;
559    while (++index <= length) {
560      event = events[index];
561      if (event[1].type === "listUnordered" || event[1].type === "listOrdered" || event[1].type === "blockQuote") {
562        if (event[0] === "enter") {
563          containerBalance++;
564        } else {
565          containerBalance--;
566        }
567        atMarker = void 0;
568      } else if (event[1].type === "lineEndingBlank") {
569        if (event[0] === "enter") {
570          if (listItem2 && !atMarker && !containerBalance && !firstBlankLineIndex) {
571            firstBlankLineIndex = index;
572          }
573          atMarker = void 0;
574        }
575      } else if (event[1].type === "linePrefix" || event[1].type === "listItemValue" || event[1].type === "listItemMarker" || event[1].type === "listItemPrefix" || event[1].type === "listItemPrefixWhitespace") {
576      } else {
577        atMarker = void 0;
578      }
579      if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) {
580        if (listItem2) {
581          tailIndex = index;
582          lineIndex = void 0;
583          while (tailIndex--) {
584            tailEvent = events[tailIndex];
585            if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") {
586              if (tailEvent[0] === "exit") continue;
587              if (lineIndex) {
588                events[lineIndex][1].type = "lineEndingBlank";
589                listSpread = true;
590              }
591              tailEvent[1].type = "lineEnding";
592              lineIndex = tailIndex;
593            } else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") {
594            } else {
595              break;
596            }
597          }
598          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {
599            listItem2._spread = true;
600          }
601          listItem2.end = point(
602            lineIndex ? events[lineIndex][1].start : event[1].end
603          );
604          events.splice(lineIndex || index, 0, ["exit", listItem2, event[2]]);
605          index++;
606          length++;
607        }
608        if (event[1].type === "listItemPrefix") {
609          listItem2 = {
610            type: "listItem",
611            _spread: false,
612            start: point(event[1].start)
613          };
614          events.splice(index, 0, ["enter", listItem2, event[2]]);
615          index++;
616          length++;
617          firstBlankLineIndex = void 0;
618          atMarker = true;
619        }
620      }
621    }
622    events[start][1]._spread = listSpread;
623    return length;
624  }
625  function setData(key, value) {
626    data[key] = value;
627  }
628  function getData(key) {
629    return data[key];
630  }
631  function point(d) {
632    return { line: d.line, column: d.column, offset: d.offset };
633  }
634  function opener(create, and) {
635    return open;
636    function open(token) {
637      enter.call(this, create(token), token);
638      if (and) and.call(this, token);
639    }
640  }
641  function buffer() {
642    this.stack.push({ type: "fragment", children: [] });
643  }
644  function enter(node, token) {
645    this.stack[this.stack.length - 1].children.push(node);
646    this.stack.push(node);
647    this.tokenStack.push(token);
648    node.position = { start: point(token.start) };
649    return node;
650  }
651  function closer(and) {
652    return close;
653    function close(token) {
654      if (and) and.call(this, token);
655      exit.call(this, token);
656    }
657  }
658  function exit(token) {
659    var node = this.stack.pop();
660    var open = this.tokenStack.pop();
661    if (!open) {
662      throw new Error(
663        "Cannot close `" + token.type + "` (" + stringifyPosition({ start: token.start, end: token.end }) + "): it\u2019s not open"
664      );
665    } else if (open.type !== token.type) {
666      throw new Error(
667        "Cannot close `" + token.type + "` (" + stringifyPosition({ start: token.start, end: token.end }) + "): a different token (`" + open.type + "`, " + stringifyPosition({ start: open.start, end: open.end }) + ") is open"
668      );
669    }
670    node.position.end = point(token.end);
671    return node;
672  }
673  function resume() {
674    return toString(this.stack.pop());
675  }
676  function onenterlistordered() {
677    setData("expectingFirstListItemValue", true);
678  }
679  function onenterlistitemvalue(token) {
680    if (getData("expectingFirstListItemValue")) {
681      this.stack[this.stack.length - 2].start = parseInt(
682        this.sliceSerialize(token),
683        10
684      );
685      setData("expectingFirstListItemValue");
686    }
687  }
688  function onexitcodefencedfenceinfo() {
689    var data2 = this.resume();
690    this.stack[this.stack.length - 1].lang = data2;
691  }
692  function onexitcodefencedfencemeta() {
693    var data2 = this.resume();
694    this.stack[this.stack.length - 1].meta = data2;
695  }
696  function onexitcodefencedfence() {
697    if (getData("flowCodeInside")) return;
698    this.buffer();
699    setData("flowCodeInside", true);
700  }
701  function onexitcodefenced() {
702    var data2 = this.resume();
703    this.stack[this.stack.length - 1].value = data2.replace(
704      /^(\r?\n|\r)|(\r?\n|\r)$/g,
705      ""
706    );
707    setData("flowCodeInside");
708  }
709  function onexitcodeindented() {
710    var data2 = this.resume();
711    this.stack[this.stack.length - 1].value = data2;
712  }
713  function onexitdefinitionlabelstring(token) {
714    var label = this.resume();
715    this.stack[this.stack.length - 1].label = label;
716    this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
717      this.sliceSerialize(token)
718    ).toLowerCase();
719  }
720  function onexitdefinitiontitlestring() {
721    var data2 = this.resume();
722    this.stack[this.stack.length - 1].title = data2;
723  }
724  function onexitdefinitiondestinationstring() {
725    var data2 = this.resume();
726    this.stack[this.stack.length - 1].url = data2;
727  }
728  function onexitatxheadingsequence(token) {
729    if (!this.stack[this.stack.length - 1].depth) {
730      this.stack[this.stack.length - 1].depth = this.sliceSerialize(
731        token
732      ).length;
733    }
734  }
735  function onexitsetextheadingtext() {
736    setData("setextHeadingSlurpLineEnding", true);
737  }
738  function onexitsetextheadinglinesequence(token) {
739    this.stack[this.stack.length - 1].depth = this.sliceSerialize(token).charCo

1384var headingAtx = __webpack_require__(26628);
1385var htmlFlow = __webpack_require__(98272);
1386var htmlText = __webpack_require__(75775);
1387var labelEnd = __webpack_require__(63734);
1388var labelStartImage = __webpack_require__(98543);
1389var labelStartLink = __webpack_require__(87196);
1390var lineEnding = __webpack_require__(43742);
1391var list = __webpack_require__(42666);
1392var setextUnderline = __webpack_require__(57720);
1393var thematicBreak = __webpack_require__(75911);
1394var document = {
1395  42: list,
1396  // Asterisk
1397  43: list,
1398  // Plus sign
1399  45: list,
1400  // Dash
1401  48: list,
1402  // 0
1403  49: list,
1404  // 1
1405  50: list,
1406  // 2
1407  51: list,
1408  // 3
1409  52: list,
1410  // 4
1411  53: list,
1412  // 5
1413  54: list,
1414  // 6
1415  55: list,
1416  // 7
1417  56: list,
1418  // 8
1419  57: list,
1420  // 9
1421  62: blockQuote
1422  // Greater than
1423};
1424var contentInitial = {
1425  91: definition
1426  // Left square bracket
1427};
1428var flowInitial = {
1429  "-2": codeIndented,
1430  // Horizontal tab
1431  "-1": codeIndented,
1432  // Virtual space
1433  32: codeIndented
1434  // Space
1435};
1436var flow = {
1437  35: headingAtx,
1438  // Number sign
1439  42: thematicBreak,
1440  // Asterisk
1441  45: [setextUnderline, thematicBreak],
1442  // Dash
1443  60: htmlFlow,
1444  // Less than
1445  61: setextUnderline,
1446  // Equals to
1447  95: thematicBreak,
1448  // Underscore
1449  96: codeFenced,
1450  // Grave accent
1451  126: codeFenced
1452  // Tilde
1453};
1454var string = {
1455  38: characterReference,
1456  // Ampersand
1457  92: characterEscape
1458  // Backslash
1459};
1460var text = {
1461  "-5": lineEnding,
1462  // Carriage return
1463  "-4": lineEnding,
1464  // Line feed
1465  "-3": lineEnding,
1466  // Carriage return + line feed
1467  33: labelStartImage,
1468  // Exclamation mark
1469  38: characterReference,
1470  // Ampersand
1471  42: attention,
1472  // Asterisk
1473  60: [autolink, htmlText],
1474  // Less than
1475  91: labelStartLink,
1476  // Left square bracket
1477  92: [hardBreakEscape, characterEscape],
1478  // Backslash
1479  93: labelEnd,
1480  // Right square bracket
1481  95: attention,
1482  // Underscore
1483  96: codeText
1484  // Grave accent
1485};
1486var insideSpan = {
1487  null: [attention, text$1.resolver]
1488};
1489var disable = {
1490  null: []
1491};
1492exports.contentInitial = contentInitial;
1493exports.disable = disable;
1494exports.document = document;
1495exports.flow = flow;
1496exports.flowInitial = flowInitial;
1497exports.insideSpan = insideSpan;
1498exports.string = string;
1499exports.text = text;
1500
1501
1502/***/ },
1503
1504/***/ 38614
1505(__unused_webpack_module, exports, __webpack_require__) {
1506
1507"use strict";
1508
1509Object.defineProperty(exports, "__esModule", ({ value: true }));
1510var markdownLineEnding = __webpack_require__(63336);
1511var factorySpace = __webpack_require__(42145);
1512var tokenize = initializeContent;
1513function initializeContent(effects) {
1514  var contentStart = effects.attempt(
1515    this.parser.constructs.contentInitial,
1516    afterContentStartConstruct,
1517    paragraphInitial
1518  );
1519  var previous;
1520  return contentStart;
1521  function afterContentStartConstruct(code) {
1522    if (code === null) {
1523      effects.consume(code);
1524      return;
1525    }
1526    effects.enter("lineEnding");
1527    effects.consume(code);
1528    effects.exit("lineEnding");
1529    return factorySpace(effects, contentStart, "linePrefix");
1530  }
1531  function paragraphInitial(code) {
1532    effects.enter("paragraph");
1533    return lineStart(code);
1534  }
1535  function lineStart(code) {
1536    var token = effects.enter("chunkText", {
1537      contentType: "text",
1538      previous
1539    });
1540    if (previous) {
1541      previous.next = token;
1542    }
1543    previous = token;
1544    return data(code);
1545  }
1546  function data(code) {
1547    if (code === null) {
1548      effects.exit("chunkText");
1549      effects.exit("paragraph");
1550      effects.consume(code);
1551      return;
1552    }
1553    if (markdownLineEnding(code)) {
1554      effects.consume(code);
1555      effects.exit("chunkText");
1556      return lineStart;
1557    }
1558    effects.consume(code);
1559    return data;
1560  }
1561}
1562exports.tokenize = tokenize;
1563
1564
1565/***/ },
1566
1567/***/ 20370
1568(__unused_webpack_module, exports, __webpack_require__) {
1569
1570"use strict";
1571
1572Object.defineProperty(exports, "__esModule", ({ value: true }));
1573var markdownLineEnding = __webpack_require__(63336);
1574var factorySpace = __webpack_require__(42145);
1575var partialBlankLine = __webpack_require__(89177);
1576var tokenize = initializeDocument;
1577var containerConstruct = {
1578  tokenize: tokenizeContainer
1579};
1580var lazyFlowConstruct = {
1581  tokenize: tokenizeLazyFlow
1582};
1583function initializeDocument(effects) {
1584  var self = this;
1585  var stack = [];
1586  var continued = 0;
1587  var inspectConstruct = {
1588    tokenize: tokenizeInspect,
1589    partial: true
1590  };
1591  var inspectResult;
1592  var childFlow;
1593  var childToken;
1594  return start;
1595  function start(code) {
1596    if (continued < stack.length) {
1597      self.containerState = stack[continued][1];
1598      return effects.attempt(
1599        stack[continued][0].continuation,
1600        documentContinue,
1601        documentContinued
1602      )(code);
1603    }
1604    return documentContinued(code);
1605  }
1606  function documentContinue(code) {
1607    continued++;
1608    return start(code);
1609  }
1610  function documentContinued(code) {
1611    if (inspectResult && inspectResult.flowContinue) {
1612      return flowStart(code);
1613    }
1614    self.interrupt = childFlow && childFlow.currentConstruct && childFlow.currentConstruct.interruptible;
1615    self.containerState = {};
1616    return effects.attempt(
1617      containerConstruct,
1618      containerContinue,
1619      flowStart
1620    )(code);
1621  }
1622  function containerContinue(code) {
1623    stack.push([self.currentConstruct, self.containerState]);
1624    self.containerState = void 0;
1625    return documentContinued(code);
1626  }
1627  function flowStart(code) {
1628    if (code === null) {
1629      exitContainers(0, true);
1630      effects.consume(code);
1631      return;
1632    }
1633    childFlow = childFlow || self.parser.flow(self.now());
1634    effects.enter("chunkFlow", {
1635      contentType: "flow",
1636      previous: childToken,
1637      _tokenizer: childFlow
1638    });
1639    return flowContinue(code);
1640  }
1641  function flowContinue(code) {
1642    if (code === null) {
1643      continueFlow(effects.exit("chunkFlow"));
1644      return flowStart(code);
1645    }
1646    if (markdownLineEnding(code)) {
1647      effects.consume(code);
1648      continueFlow(effects.exit("chunkFlow"));
1649      return effects.check(inspectConstruct, documentAfterPeek);
1650    }
1651    effects.consume(code);
1652    return flowContinue;
1653  }
1654  function documentAfterPeek(code) {
1655    exitContainers(
1656      inspectResult.continued,
1657      inspectResult && inspectResult.flowEnd
1658    );
1659    continued = 0;
1660    return start(code);
1661  }
1662  function continueFlow(token) {
1663    if (childToken) childToken.next = token;
1664    childToken = token;
1665    childFlow.lazy = inspectResult && inspectResult.lazy;
1666    childFlow.defineSkip(token.start);
1667    childFlow.write(self.sliceStream(token));
1668  }
1669  function exitContainers(size, end) {
1670    var index = stack.length;
1671    if (childFlow && end) {
1672      childFlow.write([null]);
1673      childToken = childFlow = void 0;
1674    }
1675    while (index-- > size) {
1676      self.containerState = stack[index][1];
1677      stack[index][0].exit.call(self, effects);
1678    }
1679    stack.length = size;
1680  }
1681  function tokenizeInspect(effects2, ok) {
1682    var subcontinued = 0;
1683    inspectResult = {};
1684    return inspectStart;
1685    function inspectStart(code) {
1686      if (subcontinued < stack.length) {
1687        self.containerState = stack[subcontinued][1];
1688        return effects2.attempt(
1689          stack[subcontinued][0].continuation,
1690          inspectContinue,
1691          inspectLess
1692        )(code);
1693      }
1694      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
1695        inspectResult.flowContinue = true;
1696        return inspectDone(code);
1697      }
1698      self.interrupt = childFlow.currentConstruct && childFlow.currentConstruct.interruptible;
1699      self.containerState = {};
1700      return effects2.attempt(
1701        containerConstruct,
1702        inspectFlowEnd,
1703        inspectDone
1704      )(code);
1705    }
1706    function inspectContinue(code) {
1707      subcontinued++;
1708      return self.containerState._closeFlow ? inspectFlowEnd(code) : inspectStart(code);
1709    }
1710    function inspectLess(code) {
1711      if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {
1712        self.containerState = {};
1713        return effects2.attempt(
1714          containerConstruct,
1715          inspectFlowEnd,
1716          // Maybe flow, or a blank line?
1717          effects2.attempt(
1718            lazyFlowConstruct,
1719            inspectFlowEnd,
1720            effects2.check(partialBlankLine, inspectFlowEnd, inspectLazy)
1721          )
1722        )(code);
1723      }
1724      return inspectFlowEnd(code);
1725    }
1726    function inspectLazy(code) {
1727      subcontinued = stack.length;
1728      inspectResult.lazy = true;
1729      inspectResult.flowContinue = true;
1730      return inspectDone(code);
1731    }
1732    function inspectFlowEnd(code) {
1733      inspectResult.flowEnd = true;
1734      return inspectDone(code);
1735    }
1736    function inspectDone(code) {
1737      inspectResult.continued = subcontinued;
1738      self.interrupt = self.containerState = void 0;
1739      return ok(code);
1740    }
1741  }
1742}
1743function tokenizeContainer(effects, ok, nok) {
1744  return factorySpace(
1745    effects,
1746    effects.attempt(this.parser.constructs.document, ok, nok),
1747    "linePrefix",
1748    this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4
1749  );
1750}
1751function tokenizeLazyFlow(effects, ok, nok) {
1752  return factorySpace(
1753    effects,
1754    effects.lazy(this.parser.constructs.flow, ok, nok),
1755    "linePrefix",
1756    this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4
1757  );
1758}
1759exports.tokenize = tokenize;
1760
1761
1762/***/ },
1763
1764/***/ 99887
1765(__unused_webpack_module, exports, __webpack_require__) {
1766
1767"use strict";
1768
1769Object.defineProperty(exports, "__esModule", ({ value: true }));
1770var content = __webpack_require__(56461);
1771var factorySpace = __webpack_require__(42145);
1772var partialBlankLine = __webpack_require__(89177);
1773var tokenize = initializeFlow;
1774function initializeFlow(effects) {
1775  var self = this;
1776  var initial = effects.attempt(
1777    // Try to parse a blank line.
1778    partialBlankLine,
1779    atBlankEnding,
1780    // Try to parse initial flow (essentially, only code).
1781    effects.attempt(
1782      this.parser.constructs.flowInitial,
1783      afterConstruct,
1784      factorySpace(
1785        effects,
1786        effects.attempt(
1787          this.parser.constructs.flow,
1788          afterConstruct,
1789          effects.attempt(content, afterConstruct)
1790        ),
1791        "linePrefix"
1792      )
1793    )
1794  );
1795  return initial;
1796  function atBlankEnding(code) {
1797    if (code === null) {
1798      effects.consume(code);
1799      return;
1800    }
1801    effects.enter("lineEndingBlank");
1802    effects.consume(code);
1803    effects.exit("lineEndingBlank");
1804    self.currentConstruct = void 0;
1805    return initial;
1806  }
1807  function afterConstruct(code) {
1808    if (code === null) {
1809      effects.consume(code);
1810      return;
1811    }
1812    effects.enter("lineEnding");
1813    effects.consume(code);
1814    effects.exit("lineEnding");
1815    self.currentConstruct = void 0;
1816    return initial;
1817  }
1818}
1819exports.tokenize = tokenize;
1820
1821
1822/***/ },
1823
1824/***/ 38708
1825(__unused_webpack_module, exports, __webpack_require__) {
1826
1827"use strict";
1828
1829Object.defineProperty(exports, "__esModule", ({ value: true }));
1830var assign = __webpack_require__(44552);
1831var shallow = __webpack_require__(34645);
1832var text = initializeFactory("text");
1833var string = initializeFactory("string");
1834var resolver = {
1835  resolveAll: createResolver()
1836};
1837function initializeFactory(field) {
1838  return {
1839    tokenize: initializeText,
1840    resolveAll: createResolver(
1841      field === "text" ? resolveAllLineSuffixes : void 0
1842    )
1843  };
1844  function initializeText(effects) {
1845    var self = this;
1846    var constructs = this.parser.constructs[field];
1847    var text2 = effects.attempt(constructs, start, notText);
1848    return start;
1849    function start(code) {
1850      return atBreak(code) ? text2(code) : notText(code);
1851    }
1852    function notText(code) {
1853      if (code === null) {
1854        effects.consume(code);
1855        return;
1856      }
1857      effects.enter("data");
1858      effects.consume(code);
1859      return data;
1860    }
1861    function data(code) {
1862      if (atBreak(code)) {
1863        effects.exit("data");
1864        return text2(code);
1865      }
1866      effects.consume(code);
1867      return data;
1868    }
1869    function atBreak(code) {
1870      var list = constructs[code];
1871      var index = -1;
1872      if (code === null) {
1873        return true;
1874      }
1875      if (list) {
1876        while (++index < list.length) {
1877          if (!list[index].previous || list[index].previous.call(self, self.previous)) {
1878            return true;
1879          }
1880        }
1881      }
1882    }
1883  }
1884}
1885function createResolver(extraResolver) {
1886  return resolveAllText;
1887  function resolveAllText(events, context) {
1888    var index = -1;
1889    var enter;
1890    while (++index <= events.length) {
1891      if (enter === void 0) {
1892        if (events[index] && events[index][1].type === "data") {
1893          enter = index;
1894          index++;
1895        }
1896      } else if (!events[index] || events[index][1].type !== "data") {
1897        if (index !== enter + 2) {
1898          events[enter][1].end = events[index - 1][1].end;
1899          events.splice(enter + 2, index - enter - 2);
1900          index = enter + 2;
1901        }
1902        enter = void 0;
1903      }
1904    }
1905    return extraResolver ? extraResolver(events, context) : events;
1906  }
1907}
1908function resolveAllLineSuffixes(events, context) {
1909  var eventIndex = -1;
1910  var chunks;
1911  var data;
1912  var chunk;
1913  var index;
1914  var bufferIndex;
1915  var size;
1916  var tabs;
1917  var token;
1918  while (++eventIndex <= events.length) {
1919    if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
1920      data = events[eventIndex - 1][1];
1921      chunks = context.sliceStream(data);
1922      index = chunks.length;
1923      bufferIndex = -1;
1924      size = 0;
1925      tabs = void 0;
1926      while (index--) {
1927        chunk = chunks[index];
1928        if (typeof chunk === "string") {
1929          bufferIndex = chunk.length;
1930          while (chunk.charCodeAt(bufferIndex - 1) === 32) {
1931            size++;
1932            bufferIndex--;
1933          }
1934          if (bufferIndex) break;
1935          bufferIndex = -1;
1936        } else if (chunk === -2) {
1937          tabs = true;
1938          size++;
1939        } else if (chunk === -1) ;
1940        else {
1941          index++;
1942          break;
1943        }
1944      }
1945      if (size) {
1946        token = {
1947          type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing",
1948          start: {
1949            line: data.end.line,
1950            column: data.end.column - size,
1951            offset: data.end.offset - size,
1952            _index: data.start._index + index,
1953            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex
1954          },
1955          end: shallow(data.end)
1956        };
1957        data.end = shallow(token.start);
1958        if (data.start.offset === data.end.offset) {
1959          assign(data, token);
1960        } else {
1961          events.splice(
1962            eventIndex,
1963            0,
1964            ["enter", token, context],
1965            ["exit", token, context]
1966          );
1967          eventIndex += 2;
1968        }
1969      }
1970      eventIndex++;
1971    }
1972  }
1973  return events;
1974}
1975exports.resolver = resolver;
1976exports.string = string;
1977exports.text = text;
1978
1979
1980/***/ },
1981
1982/***/ 95895
1983(module, __unused_webpack_exports, __webpack_require__) {
1984
1985"use strict";
1986
1987var content = __webpack_require__(38614);
1988var document = __webpack_require__(20370);
1989var flow = __webpack_require__(99887);
1990var text = __webpack_require__(38708);
1991var combineExtensions = __webpack_require__(67511);
1992var createTokenizer = __webpack_require__(99573);
1993var miniflat = __webpack_require__(56489);
1994var constructs = __webpack_require__(78716);
1995function parse(options) {
1996  var settings = options || {};
1997  var parser = {
1998    defined: [],
1999    constructs: combineExtensions(
2000      [constructs].concat(miniflat(settings.extensions))
2001    ),
2002    content: create(content),
2003    document: create(document),
2004    flow: create(flow),
2005    string: create(text.string),
2006    text: create(text.text)
2007  };
2008  return parser;
2009  function create(initializer) {
2010    return creator;
2011    function creator(from) {
2012      return createTokenizer(parser, initializer, from);
2013    }
2014  }
2015}
2016module.exports = parse;
2017
2018
2019/***/ },
2020
2021/***/ 23199
2022(module, __unused_webpack_exports, __webpack_require__) {
2023
2024"use strict";
2025
2026var subtokenize = __webpack_require__(26306);
2027function postprocess(events) {
2028  while (!subtokenize(events)) {
2029  }
2030  return events;
2031}
2032module.exports = postprocess;
2033
2034
2035/***/ },
2036
2037/***/ 52660
2038(module) {
2039
2040"use strict";
2041
2042var search = /[\0\t\n\r]/g;
2043function preprocess() {
2044  var start = true;
2045  var column = 1;
2046  var buffer = "";
2047  var atCarriageReturn;
2048  return preprocessor;
2049  function preprocessor(value, encoding, end) {
2050    var chunks = [];
2051    var match;
2052    var next;
2053    var startPosition;
2054    var endPosition;
2055    var code;
2056    value = buffer + value.toString(encoding);
2057    startPosition = 0;
2058    buffer = "";
2059    if (start) {
2060      if (value.charCodeAt(0) === 65279) {
2061        startPosition++;
2062      }
2063      start = void 0;
2064    }
2065    while (startPosition < value.length) {
2066      search.lastIndex = startPosition;
2067      match = search.exec(value);
2068      endPosition = match ? match.index : value.length;
2069      code = value.charCodeAt(endPosition);
2070      if (!match) {
2071        buffer = value.slice(startPosition);
2072        break;
2073      }
2074      if (code === 10 && startPosition === endPosition && atCarriageReturn) {
2075        chunks.push(-3);
2076        atCarriageReturn = void 0;
2077      } else {
2078        if (atCarriageReturn) {
2079          chunks.push(-5);
2080          atCarriageReturn = void 0;
2081        }
2082        if (startPosition < endPosition) {
2083          chunks.push(value.slice(startPosition, endPosition));
2084          column += endPosition - startPosition;
2085        }
2086        if (code === 0) {
2087          chunks.push(65533);
2088          column++;
2089        } else if (code === 9) {
2090          next = Math.ceil(column / 4) * 4;
2091          chunks.push(-2);
2092          while (column++ < next) chunks.push(-1);
2093        } else if (code === 10) {
2094          chunks.push(-4);
2095          column = 1;
2096        } else {
2097          atCarriageReturn = true;
2098          column = 1;
2099        }
2100      }
2101      startPosition = endPosition + 1;
2102    }
2103    if (end) {
2104      if (atCarriageReturn) chunks.push(-5);
2105      if (buffer) chunks.push(buffer);
2106      chunks.push(null);
2107    }
2108    return chunks;
2109  }
2110}
2111module.exports = preprocess;
2112
2113
2114/***/ },
2115
2116/***/ 62226
2117(module, __unused_webpack_exports, __webpack_require__) {
2118
2119"use strict";
2120
2121var chunkedPush = __webpack_require__(90638);
2122var chunkedSplice = __webpack_require__(50638);
2123var classifyCharacter = __webpack_require__(13598);
2124var movePoint = __webpack_require__(99163);
2125var resolveAll = __webpack_require__(33399);
2126var shallow = __webpack_require__(34645);
2127var attention = {
2128  name: "attention",
2129  tokenize: tokenizeAttention,
2130  resolveAll: resolveAllAttention
2131};
2132function resolveAllAttention(events, context) {
2133  var index = -1;
2134  var open;
2135  var group;
2136  var text;
2137  var openingSequence;
2138  var closingSequence;
2139  var use;
2140  var nextEvents;
2141  var offset;
2142  while (++index < events.length) {
2143    if (events[index][0] === "enter" && events[index][1].type === "attentionSequence" && events[index][1]._close) {
2144      open = index;
2145      while (open--) {
2146        if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && // If the markers are the same:
2147        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {
2148          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {
2149            continue;
2150          }
2151          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
2152          openingSequence = {
2153            type: use > 1 ? "strongSequence" : "emphasisSequence",
2154            start: movePoint(shallow(events[open][1].end), -use),
2155            end: shallow(events[open][1].end)
2156          };
2157          closingSequence = {
2158            type: use > 1 ? "strongSequence" : "emphasisSequence",
2159            start: shallow(events[index][1].start),
2160            end: movePoint(shallow(events[index][1].start), use)
2161          };
2162          text = {
2163            type: use > 1 ? "strongText" : "emphasisText",
2164            start: shallow(events[open][1].end),
2165            end: shallow(events[index][1].start)
2166          };
2167          group = {
2168            type: use > 1 ? "strong" : "emphasis",
2169            start: shallow(openingSequence.start),
2170            end: shallow(closingSequence.end)
2171          };
2172          events[open][1].end = shallow(openingSequence.start);
2173          events[index][1].start = shallow(closingSequence.end);
2174          nextEvents = [];
2175          if (events[open][1].end.offset - events[open][1].start.offset) {
2176            nextEvents = chunkedPush(nextEvents, [
2177              ["enter", events[open][1], context],
2178              ["exit", events[open][1], context]
2179            ]);
2180          }
2181          nextEvents = chunkedPush(nextEvents, [
2182            ["enter", group, context],
2183            ["enter", openingSequence, context],
2184            ["exit", openingSequence, context],
2185            ["enter", text, context]
2186          ]);
2187          nextEvents = chunkedPush(
2188            nextEvents,
2189            resolveAll(
2190              context.parser.constructs.insideSpan.null,
2191              events.slice(open + 1, index),
2192              context
2193            )
2194          );
2195          nextEvents = chunkedPush(nextEvents, [
2196            ["exit", text, context],
2197            ["enter", closingSequence, context],
2198            ["exit", closingSequence, context],
2199            ["exit", group, context]
2200          ]);
2201          if (events[index][1].end.offset - events[index][1].start.offset) {
2202            offset = 2;
2203            nextEvents = chunkedPush(nextEvents, [
2204              ["enter", events[index][1], context],
2205              ["exit", events[index][1], context]
2206            ]);
2207          } else {
2208            offset = 0;
2209          }
2210          chunkedSplice(events, open - 1, index - open + 3, nextEvents);
2211          index = open + nextEvents.length - offset - 2;
2212          break;
2213        }
2214      }
2215    }
2216  }
2217  index = -1;
2218  while (++index < events.length) {
2219    if (events[index][1].type === "attentionSequence") {
2220      events[index][1].type = "data";
2221    }
2222  }
2223  return events;
2224}
2225function tokenizeAttention(effects, ok) {
2226  var before = classifyCharacter(this.previous);
2227  var marker;
2228  return start;
2229  function start(code) {
2230    effects.enter("attentionSequence");
2231    marker = code;
2232    return sequence(code);
2233  }
2234  function sequence(code) {
2235    var token;
2236    var after;
2237    var open;
2238    var close;
2239    if (code === marker) {
2240      effects.consume(code);
2241      return sequence;
2242    }
2243    token = effects.exit("attentionSequence");
2244    after = classifyCharacter(code);
2245    open = !after || after === 2 && before;
2246    close = !before || before === 2 && after;
2247    token._open = marker === 42 ? open : open && (before || !close);
2248    token._close = marker === 42 ? close : close && (after || !open);
2249    return ok(code);
2250  }
2251}
2252module.exports = attention;
2253
2254
2255/***/ },
2256
2257/***/ 5729
2258(module, __unused_webpack_exports, __webpack_require__) {
2259
2260"use strict";
2261
2262var asciiAlpha = __webpack_require__(40558);
2263var asciiAlphanumeric = __webpack_require__(88567);
2264var asciiAtext = __webpack_require__(89806);
2265var asciiControl = __webpack_require__(7955);
2266var autolink = {
2267  name: "autolink",
2268  tokenize: tokenizeAutolink
2269};
2270function tokenizeAutolink(effects, ok, nok) {
2271  var size = 1;
2272  return start;
2273  function start(code) {
2274    effects.enter("autolink");
2275    effects.enter("autolinkMarker");
2276    effects.consume(code);
2277    effects.exit("autolinkMarker");
2278    effects.enter("autolinkProtocol");
2279    return open;
2280  }
2281  function open(code) {
2282    if (asciiAlpha(code)) {
2283      effects.consume(code);
2284      return schemeOrEmailAtext;
2285    }
2286    return asciiAtext(code) ? emailAtext(code) : nok(code);
2287  }
2288  function schemeOrEmailAtext(code) {
2289    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);
2290  }
2291  function schemeInsideOrEmailAtext(code) {
2292    if (code === 58) {
2293      effects.consume(code);
2294      return urlInside;
2295    }
2296    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {
2297      effects.consume(code);
2298      return schemeInsideOrEmailAtext;
2299    }
2300    return emailAtext(code);
2301  }
2302  function urlInside(code) {
2303    if (code === 62) {
2304      effects.exit("autolinkProtocol");
2305      return end(code);
2306    }
2307    if (code === 32 || code === 60 || asciiControl(code)) {
2308      return nok(code);
2309    }
2310    effects.consume(code);
2311    return urlInside;
2312  }
2313  function emailAtext(code) {
2314    if (code === 64) {
2315      effects.consume(code);
2316      size = 0;
2317      return emailAtSignOrDot;
2318    }
2319    if (asciiAtext(code)) {
2320      effects.consume(code);
2321      return emailAtext;
2322    }
2323    return nok(code);
2324  }
2325  function emailAtSignOrDot(code) {
2326    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);
2327  }
2328  function emailLabel(code) {
2329    if (code === 46) {
2330      effects.consume(code);
2331      size = 0;
2332      return emailAtSignOrDot;
2333    }
2334    if (code === 62) {
2335      effects.exit("autolinkProtocol").type = "autolinkEmail";
2336      return end(code);
2337    }
2338    return emailValue(code);
2339  }
2340  function emailValue(code) {
2341    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
2342      effects.consume(code);
2343      return code === 45 ? emailValue : emailLabel;
2344    }
2345    return nok(code);
2346  }
2347  function end(code) {
2348    effects.enter("autolinkMarker");
2349    effects.consume(code);
2350    effects.exit("autolinkMarker");
2351    effects.exit("autolink");
2352    return ok;
2353  }
2354}
2355module.exports = autolink;
2356
2357
2358/***/ },
2359
2360/***/ 77372
2361(module, __unused_webpack_exports, __webpack_require__) {
2362
2363"use strict";
2364
2365var markdownSpace = __webpack_require__(24248);
2366var factorySpace = __webpack_require__(42145);
2367var blockQuote = {
2368  name: "blockQuote",
2369  tokenize: tokenizeBlockQuoteStart,
2370  continuation: {
2371    tokenize: tokenizeBlockQuoteContinuation
2372  },
2373  exit
2374};
2375function tokenizeBlockQuoteStart(effects, ok, nok) {
2376  var self = this;
2377  return start;
2378  function start(code) {
2379    if (code === 62) {
2380      if (!self.containerState.open) {
2381        effects.enter("blockQuote", {
2382          _container: true
2383        });
2384        self.containerState.open = true;
2385      }
2386      effects.enter("blockQuotePrefix");
2387      effects.enter("blockQuoteMarker");
2388      effects.consume(code);
2389      effects.exit("blockQuoteMarker");
2390      return after;
2391    }
2392    return nok(code);
2393  }
2394  function after(code) {
2395    if (markdownSpace(code)) {
2396      effects.enter("blockQuotePrefixWhitespace");
2397      effects.consume(code);
2398      effects.exit("blockQuotePrefixWhitespace");
2399      effects.exit("blockQuotePrefix");
2400      return ok;
2401    }
2402    effects.exit("blockQuotePrefix");
2403    return ok(code);
2404  }
2405}
2406function tokenizeBlockQuoteContinuation(effects, ok, nok) {
2407  return factorySpace(
2408    effects,
2409    effects.attempt(blockQuote, ok, nok),
2410    "linePrefix",
2411    this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4
2412  );
2413}
2414function exit(effects) {
2415  effects.exit("blockQuote");
2416}
2417module.exports = blockQuote;
2418
2419
2420/***/ },
2421
2422/***/ 73279
2423(module, __unused_webpack_exports, __webpack_require__) {
2424
2425"use strict";
2426
2427var asciiPunctuation = __webpack_require__(72178);
2428var characterEscape = {
2429  name: "characterEscape",
2430  tokenize: tokenizeCharacterEscape
2431};
2432function tokenizeCharacterEscape(effects, ok, nok) {
2433  return start;
2434  function start(code) {
2435    effects.enter("characterEscape");
2436    effects.enter("escapeMarker");
2437    effects.consume(code);
2438    effects.exit("escapeMarker");
2439    return open;
2440  }
2441  function open(code) {
2442    if (asciiPunctuation(code)) {
2443      effects.enter("characterEscapeValue");
2444      effects.consume(code);
2445      effects.exit("characterEscapeValue");
2446      effects.exit("characterEscape");
2447      return ok;
2448    }
2449    return nok(code);
2450  }
2451}
2452module.exports = characterEscape;
2453
2454
2455/***/ },
2456
2457/***/ 7115
2458(module, __unused_webpack_exports, __webpack_require__) {
2459
2460"use strict";
2461
2462var decodeEntity = __webpack_require__(72859);
2463var asciiAlphanumeric = __webpack_require__(88567);
2464var asciiDigit = __webpack_require__(58488);
2465var asciiHexDigit = __webpack_require__(56875);
2466function _interopDefaultLegacy(e) {
2467  return e && typeof e === "object" && "default" in e ? e : { default: e };
2468}
2469var decodeEntity__default = /* @__PURE__ */ _interopDefaultLegacy(decodeEntity);
2470var characterReference = {
2471  name: "characterReference",
2472  tokenize: tokenizeCharacterReference
2473};
2474function tokenizeCharacterReference(effects, ok, nok) {
2475  var self = this;
2476  var size = 0;
2477  var max;
2478  var test;
2479  return start;
2480  function start(code) {
2481    effects.enter("characterReference");
2482    effects.enter("characterReferenceMarker");
2483    effects.consume(code);
2484    effects.exit("characterReferenceMarker");
2485    return open;
2486  }
2487  function open(code) {
2488    if (code === 35) {
2489      effects.enter("characterReferenceMarkerNumeric");
2490      effects.consume(code);
2491      effects.exit("characterReferenceMarkerNumeric");
2492      return numeric;
2493    }
2494    effects.enter("characterReferenceValue");
2495    max = 31;
2496    test = asciiAlphanumeric;
2497    return value(code);
2498  }
2499  function numeric(code) {
2500    if (code === 88 || code === 120) {
2501      effects.enter("characterReferenceMarkerHexadecimal");
2502      effects.consume(code);
2503      effects.exit("characterReferenceMarkerHexadecimal");
2504      effects.enter("characterReferenceValue");
2505      max = 6;
2506      test = asciiHexDigit;
2507      return value;
2508    }
2509    effects.enter("characterReferenceValue");
2510    max = 7;
2511    test = asciiDigit;
2512    return value(code);
2513  }
2514  function value(code) {
2515    var token;
2516    if (code === 59 && size) {
2517      token = effects.exit("characterReferenceValue");
2518      if (test === asciiAlphanumeric && !decodeEntity__default["default"](self.sliceSerialize(token))) {
2519        return nok(code);
2520      }
2521      effects.enter("characterReferenceMarker");
2522      effects.consume(code);
2523      effects.exit("characterReferenceMarker");
2524      effects.exit("characterReference");
2525      return ok;
2526    }
2527    if (test(code) && size++ < max) {
2528      effects.consume(code);
2529      return value;
2530    }
2531    return nok(code);
2532  }
2533}
2534module.exports = characterReference;
2535
2536
2537/***/ },
2538
2539/***/ 44407
2540(module, __unused_webpack_exports, __webpack_require__) {
2541
2542"use strict";
2543
2544var markdownLineEnding = __webpack_require__(63336);
2545var markdownLineEndingOrSpace = __webpack_require__(2575);
2546var prefixSize = __webpack_require__(71795);
2547var factorySpace = __webpack_require__(42145);
2548var codeFenced = {
2549  name: "codeFenced",
2550  tokenize: tokenizeCodeFenced,
2551  concrete: true
2552};
2553function tokenizeCodeFenced(effects, ok, nok) {
2554  var self = this;
2555  var closingFenceConstruct = {
2556    tokenize: tokenizeClosingFence,
2557    partial: true
2558  };
2559  var initialPrefix = prefixSize(this.events, "linePrefix");
2560  var sizeOpen = 0;
2561  var marker;
2562  return start;
2563  function start(code) {
2564    effects.enter("codeFenced");
2565    effects.enter("codeFencedFence");
2566    effects.enter("codeFencedFenceSequence");
2567    marker = code;
2568    return sequenceOpen(code);
2569  }
2570  function sequenceOpen(code) {
2571    if (code === marker) {
2572      effects.consume(code);
2573      sizeOpen++;
2574      return sequenceOpen;
2575    }
2576    effects.exit("codeFencedFenceSequence");
2577    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, "whitespace")(code);
2578  }
2579  function infoOpen(code) {
2580    if (code === null || markdownLineEnding(code)) {
2581      return openAfter(code);
2582    }
2583    effects.enter("codeFencedFenceInfo");
2584    effects.enter("chunkString", {
2585      contentType: "string"
2586    });
2587    return info(code);
2588  }
2589  function info(code) {
2590    if (code === null || markdownLineEndingOrSpace(code)) {
2591      effects.exit("chunkString");
2592      effects.exit("codeFencedFenceInfo");
2593      return factorySpace(effects, infoAfter, "whitespace")(code);
2594    }
2595    if (code === 96 && code === marker) return nok(code);
2596    effects.consume(code);
2597    return info;
2598  }
2599  function infoAfter(code) {
2600    if (code === null || markdownLineEnding(code)) {
2601      return openAfter(code);
2602    }
2603    effects.enter("codeFencedFenceMeta");
2604    effects.enter("chunkString", {
2605      contentType: "string"
2606    });
2607    return meta(code);
2608  }
2609  function meta(code) {
2610    if (code === null || markdownLineEnding(code)) {
2611      effects.exit("chunkString");
2612      effects.exit("codeFencedFenceMeta");
2613      return openAfter(code);
2614    }
2615    if (code === 96 && code === marker) return nok(code);
2616    effects.consume(code);
2617    return meta;
2618  }
2619  function openAfter(code) {
2620    effects.exit("codeFencedFence");
2621    return self.interrupt ? ok(code) : content(code);
2622  }
2623  function content(code) {
2624    if (code === null) {
2625      return after(code);
2626    }
2627    if (markdownLineEnding(code)) {
2628      effects.enter("lineEnding");
2629      effects.consume(code);
2630      effects.exit("lineEnding");
2631      return effects.attempt(
2632        closingFenceConstruct,
2633        after,
2634        initialPrefix ? factorySpace(effects, content, "linePrefix", initialPrefix + 1) : content
2635      );
2636    }
2637    effects.enter("codeFlowValue");
2638    return contentContinue(code);
2639  }
2640  function contentContinue(code) {
2641    if (code === null || markdownLineEnding(code)) {
2642      effects.exit("codeFlowValue");
2643      return content(code);
2644    }
2645    effects.consume(code);
2646    return contentContinue;
2647  }
2648  function after(code) {
2649    effects.exit("codeFenced");
2650    return ok(code);
2651  }
2652  function tokenizeClosingFence(effects2, ok2, nok2) {
2653    var size = 0;
2654    return factorySpace(
2655      effects2,
2656      closingSequenceStart,
2657      "linePrefix",
2658      this.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4
2659    );
2660    function closingSequenceStart(code) {
2661      effects2.enter("codeFencedFence");
2662      effects2.enter("codeFencedFenceSequence");
2663      return closingSequence(code);
2664    }
2665    function closingSequence(code) {
2666      if (code === marker) {
2667        effects2.consume(code);
2668        size++;
2669        return closingSequence;
2670      }
2671      if (size < sizeOpen) return nok2(code);
2672      effects2.exit("codeFencedFenceSequence");
2673      return factorySpace(effects2, closingSequenceEnd, "whitespace")(code);
2674    }
2675    function closingSequenceEnd(code) {
2676      if (code === null || markdownLineEnding(code)) {
2677        effects2.exit("codeFencedFence");
2678        return ok2(code);
2679      }
2680      return nok2(code);
2681    }
2682  }
2683}
2684module.exports = codeFenced;
2685
2686
2687/***/ },
2688
2689/***/ 59487
2690(module, __unused_webpack_exports, __webpack_require__) {
2691
2692"use strict";
2693
2694var markdownLineEnding = __webpack_require__(63336);
2695var chunkedSplice = __webpack_require__(50638);
2696var prefixSize = __webpack_require__(71795);
2697var factorySpace = __webpack_require__(42145);
2698var codeIndented = {
2699  name: "codeIndented",
2700  tokenize: tokenizeCodeIndented,
2701  resolve: resolveCodeIndented
2702};
2703var indentedContentConstruct = {
2704  tokenize: tokenizeIndentedContent,
2705  partial: true
2706};
2707function resolveCodeIndented(events, context) {
2708  var code = {
2709    type: "codeIndented",
2710    start: events[0][1].start,
2711    end: events[events.length - 1][1].end
2712  };
2713  chunkedSplice(events, 0, 0, [["enter", code, context]]);
2714  chunkedSplice(events, events.length, 0, [["exit", code, context]]);
2715  return events;
2716}
2717function tokenizeCodeIndented(effects, ok, nok) {
2718  return effects.attempt(indentedContentConstruct, afterPrefix, nok);
2719  function afterPrefix(code) {
2720    if (code === null) {
2721      return ok(code);
2722    }
2723    if (markdownLineEnding(code)) {
2724      return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code);
2725    }
2726    effects.enter("codeFlowValue");
2727    return content(code);
2728  }
2729  function content(code) {
2730    if (code === null || markdownLineEnding(code)) {
2731      effects.exit("codeFlowValue");
2732      return afterPrefix(code);
2733    }
2734    effects.consume(code);
2735    return content;
2736  }
2737}
2738function tokenizeIndentedContent(effects, ok, nok) {
2739  var self = this;
2740  return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1);
2741  function afterPrefix(code) {
2742    if (markdownLineEnding(code)) {
2743      effects.enter("lineEnding");
2744      effects.consume(code);
2745      effects.exit("lineEnding");
2746      return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1);
2747    }
2748    return prefixSize(self.events, "linePrefix") < 4 ? nok(code) : ok(code);
2749  }
2750}
2751module.exports = codeIndented;
2752
2753
2754/***/ },
2755
2756/***/ 2323
2757(module, __unused_webpack_exports, __webpack_require__) {
2758
2759"use strict";
2760
2761var markdownLineEnding = __webpack_require__(63336);
2762var codeText = {
2763  name: "codeText",
2764  tokenize: tokenizeCodeText,
2765  resolve: resolveCodeText,
2766  previous
2767};
2768function resolveCodeText(events) {
2769  var tailExitIndex = events.length - 4;
2770  var headEnterIndex = 3;
2771  var index;
2772  var enter;
2773  if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
2774    index = headEnterIndex;
2775    while (++index < tailExitIndex) {
2776      if (events[index][1].type === "codeTextData") {
2777        events[tailExitIndex][1].type = events[headEnterIndex][1].type = "codeTextPadding";
2778        headEnterIndex += 2;
2779        tailExitIndex -= 2;
2780        break;
2781      }
2782    }
2783  }
2784  index = headEnterIndex - 1;
2785  tailExitIndex++;
2786  while (++index <= tailExitIndex) {
2787    if (enter === void 0) {
2788      if (index !== tailExitIndex && events[index][1].type !== "lineEnding") {
2789        enter = index;
2790      }
2791    } else if (index === tailExitIndex || events[index][1].type === "lineEnding") {
2792      events[enter][1].type = "codeTextData";
2793      if (index !== enter + 2) {
2794        events[enter][1].end = events[index - 1][1].end;
2795        events.splice(enter + 2, index - enter - 2);
2796        tailExitIndex -= index - enter - 2;
2797        index = enter + 2;
2798      }
2799      enter = void 0;
2800    }
2801  }
2802  return events;
2803}
2804function previous(code) {
2805  return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
2806}
2807function tokenizeCodeText(effects, ok, nok) {
2808  var sizeOpen = 0;
2809  var size;
2810  var token;
2811  return start;
2812  function start(code) {
2813    effects.enter("codeText");
2814    effects.enter("codeTextSequence");
2815    return openingSequence(code);
2816  }
2817  function openingSequence(code) {
2818    if (code === 96) {
2819      effects.consume(code);
2820      sizeOpen++;
2821      return openingSequence;
2822    }
2823    effects.exit("codeTextSequence");
2824    return gap(code);
2825  }
2826  function gap(code) {
2827    if (code === null) {
2828      return nok(code);
2829    }
2830    if (code === 96) {
2831      token = effects.enter("codeTextSequence");
2832      size = 0;
2833      return closingSequence(code);
2834    }
2835    if (code === 32) {
2836      effects.enter("space");
2837      effects.consume(code);
2838      effects.exit("space");
2839      return gap;
2840    }
2841    if (markdownLineEnding(code)) {
2842      effects.enter("lineEnding");
2843      effects.consume(code);
2844      effects.exit("lineEnding");
2845      return gap;
2846    }
2847    effects.enter("codeTextData");
2848    return data(code);
2849  }
2850  function data(code) {
2851    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {
2852      effects.exit("codeTextData");
2853      return gap(code);
2854    }
2855    effects.consume(code);
2856    return data;
2857  }
2858  function closingSequence(code) {
2859    if (code === 96) {
2860      effects.consume(code);
2861      size++;
2862      return closingSequence;
2863    }
2864    if (size === sizeOpen) {
2865      effects.exit("codeTextSequence");
2866      effects.exit("codeText");
2867      return ok(code);
2868    }
2869    token.type = "codeTextData";
2870    return data(code);
2871  }
2872}
2873module.exports = codeText;
2874
2875
2876/***/ },
2877
2878/***/ 56461
2879(module, __unused_webpack_exports, __webpack_require__) {
2880
2881"use strict";
2882
2883var markdownLineEnding = __webpack_require__(63336);
2884var prefixSize = __webpack_require__(71795);
2885var subtokenize = __webpack_require__(26306);
2886var factorySpace = __webpack_require__(42145);
2887var content = {
2888  tokenize: tokenizeContent,
2889  resolve: resolveContent,
2890  interruptible: true,
2891  lazy: true
2892};
2893var continuationConstruct = {
2894  tokenize: tokenizeContinuation,
2895  partial: true
2896};
2897function resolveContent(events) {
2898  subtokenize(events);
2899  return events;
2900}
2901function tokenizeContent(effects, ok) {
2902  var previous;
2903  return start;
2904  function start(code) {
2905    effects.enter("content");
2906    previous = effects.enter("chunkContent", {
2907      contentType: "content"
2908    });
2909    return data(code);
2910  }
2911  function data(code) {
2912    if (code === null) {
2913      return contentEnd(code);
2914    }
2915    if (markdownLineEnding(code)) {
2916      return effects.check(
2917        continuationConstruct,
2918        contentContinue,
2919        contentEnd
2920      )(code);
2921    }
2922    effects.consume(code);
2923    return data;
2924  }
2925  function contentEnd(code) {
2926    effects.exit("chunkContent");
2927    effects.exit("content");
2928    return ok(code);
2929  }
2930  function contentContinue(code) {
2931    effects.consume(code);
2932    effects.exit("chunkContent");
2933    previous = previous.next = effects.enter("chunkContent", {
2934      contentType: "content",
2935      previous
2936    });
2937    return data;
2938  }
2939}
2940function tokenizeContinuation(effects, ok, nok) {
2941  var self = this;
2942  return startLookahead;
2943  function startLookahead(code) {
2944    effects.enter("lineEnding");
2945    effects.consume(code);
2946    effects.exit("lineEnding");
2947    return factorySpace(effects, prefixed, "linePrefix");
2948  }
2949  function prefixed(code) {
2950    if (code === null || markdownLineEnding(code)) {
2951      return nok(code);
2952    }
2953    if (self.parser.constructs.disable.null.indexOf("codeIndented") > -1 || prefixSize(self.events, "linePrefix") < 4) {
2954      return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);
2955    }
2956    return ok(code);
2957  }
2958}
2959module.exports = content;
2960
2961
2962/***/ },
2963
2964/***/ 50471
2965(module, __unused_webpack_exports, __webpack_require__) {
2966
2967"use strict";
2968
2969var markdownLineEnding = __webpack_require__(63336);
2970var markdownLineEndingOrSpace = __webpack_require__(2575);
2971var normalizeIdentifier = __webpack_require__(17904);
2972var factoryDestination = __webpack_require__(53263);
2973var factoryLabel = __webpack_require__(27465);
2974var factorySpace = __webpack_require__(42145);
2975var factoryWhitespace = __webpack_require__(69726);
2976var factoryTitle = __webpack_require__(47065);
2977var definition = {
2978  name: "definition",
2979  tokenize: tokenizeDefinition
2980};
2981var titleConstruct = {
2982  tokenize: tokenizeTitle,
2983  partial: true
2984};
2985function tokenizeDefinition(effects, ok, nok) {
2986  var self = this;
2987  var identifier;
2988  return start;
2989  function start(code) {
2990    effects.enter("definition");
2991    return factoryLabel.call(
2992      self,
2993      effects,
2994      labelAfter,
2995      nok,
2996      "definitionLabel",
2997      "definitionLabelMarker",
2998      "definitionLabelString"
2999    )(code);
3000  }
3001  function labelAfter(code) {
3002    identifier = normalizeIdentifier(
3003      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
3004    );
3005    if (code === 58) {
3006      effects.enter("definitionMarker");
3007      effects.consume(code);
3008      effects.exit("definitionMarker");
3009      return factoryWhitespace(
3010        effects,
3011        factoryDestination(
3012          effects,
3013          effects.attempt(
3014            titleConstruct,
3015            factorySpace(effects, after, "whitespace"),
3016            factorySpace(effects, after, "whitespace")
3017          ),
3018          nok,
3019          "definitionDestination",
3020          "definitionDestinationLiteral",
3021          "definitionDestinationLiteralMarker",
3022          "definitionDestinationRaw",
3023          "definitionDestinationString"
3024        )
3025      );
3026    }
3027    return nok(code);
3028  }
3029  function after(code) {
3030    if (code === null || markdownLineEnding(code)) {
3031      effects.exit("definition");
3032      if (self.parser.defined.indexOf(identifier) < 0) {
3033        self.parser.defined.push(identifier);
3034      }
3035      return ok(code);
3036    }
3037    return nok(code);
3038  }
3039}
3040function tokenizeTitle(effects, ok, nok) {
3041  return start;
3042  function start(code) {
3043    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);
3044  }
3045  function before(code) {
3046    if (code === 34 || code === 39 || code === 40) {
3047      return factoryTitle(
3048        effects,
3049        factorySpace(effects, after, "whitespace"),
3050        nok,
3051        "definitionTitle",
3052        "definitionTitleMarker",
3053        "definitionTitleString"
3054      )(code);
3055    }
3056    return nok(code);
3057  }
3058  function after(code) {
3059    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
3060  }
3061}
3062module.exports = definition;
3063
3064
3065/***/ },
3066
3067/***/ 53263
3068(module, __unused_webpack_exports, __webpack_require__) {
3069
3070"use strict";
3071
3072var asciiControl = __webpack_require__(7955);
3073var markdownLineEndingOrSpace = __webpack_require__(2575);
3074var markdownLineEnding = __webpack_require__(63336);
3075function destinationFactory(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {
3076  var limit = max || Infinity;
3077  var balance = 0;
3078  return start;
3079  function start(code) {
3080    if (code === 60) {
3081      effects.enter(type);
3082      effects.enter(literalType);
3083      effects.enter(literalMarkerType);
3084      effects.consume(code);
3085      effects.exit(literalMarkerType);
3086      return destinationEnclosedBefore;
3087    }
3088    if (asciiControl(code) || code === 41) {
3089      return nok(code);
3090    }
3091    effects.enter(type);
3092    effects.enter(rawType);
3093    effects.enter(stringType);
3094    effects.enter("chunkString", {
3095      contentType: "string"
3096    });
3097    return destinationRaw(code);
3098  }
3099  function destinationEnclosedBefore(code) {
3100    if (code === 62) {
3101      effects.enter(literalMarkerType);
3102      effects.consume(code);
3103      effects.exit(literalMarkerType);
3104      effects.exit(literalType);
3105      effects.exit(type);
3106      return ok;
3107    }
3108    effects.enter(stringType);
3109    effects.enter("chunkString", {
3110      contentType: "string"
3111    });
3112    return destinationEnclosed(code);
3113  }
3114  function destinationEnclosed(code) {
3115    if (code === 62) {
3116      effects.exit("chunkString");
3117      effects.exit(stringType);
3118      return destinationEnclosedBefore(code);
3119    }
3120    if (code === null || code === 60 || markdownLineEnding(code)) {
3121      return nok(code);
3122    }
3123    effects.consume(code);
3124    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;
3125  }
3126  function destinationEnclosedEscape(code) {
3127    if (code === 60 || code === 62 || code === 92) {
3128      effects.consume(code);
3129      return destinationEnclosed;
3130    }
3131    return destinationEnclosed(code);
3132  }
3133  function destinationRaw(code) {
3134    if (code === 40) {
3135      if (++balance > limit) return nok(code);
3136      effects.consume(code);
3137      return destinationRaw;
3138    }
3139    if (code === 41) {
3140      if (!balance--) {
3141        effects.exit("chunkString");
3142        effects.exit(stringType);
3143        effects.exit(rawType);
3144        effects.exit(type);
3145        return ok(code);
3146      }
3147      effects.consume(code);
3148      return destinationRaw;
3149    }
3150    if (code === null || markdownLineEndingOrSpace(code)) {
3151      if (balance) return nok(code);
3152      effects.exit("chunkString");
3153      effects.exit(stringType);
3154      effects.exit(rawType);
3155      effects.exit(type);
3156      return ok(code);
3157    }
3158    if (asciiControl(code)) return nok(code);
3159    effects.consume(code);
3160    return code === 92 ? destinationRawEscape : destinationRaw;
3161  }
3162  function destinationRawEscape(code) {
3163    if (code === 40 || code === 41 || code === 92) {
3164      effects.consume(code);
3165      return destinationRaw;
3166    }
3167    return destinationRaw(code);
3168  }
3169}
3170module.exports = destinationFactory;
3171
3172
3173/***/ },
3174
3175/***/ 27465
3176(module, __unused_webpack_exports, __webpack_require__) {
3177
3178"use strict";
3179
3180var markdownLineEnding = __webpack_require__(63336);
3181var markdownSpace = __webpack_require__(24248);
3182function labelFactory(effects, ok, nok, type, markerType, stringType) {
3183  var self = this;
3184  var size = 0;
3185  var data;
3186  return start;
3187  function start(code) {
3188    effects.enter(type);
3189    effects.enter(markerType);
3190    effects.consume(code);
3191    effects.exit(markerType);
3192    effects.enter(stringType);
3193    return atBreak;
3194  }
3195  function atBreak(code) {
3196    if (code === null || code === 91 || code === 93 && !data || /* c8 ignore next */
3197    code === 94 && /* c8 ignore next */
3198    !size && /* c8 ignore next */
3199    "_hiddenFootnoteSupport" in self.parser.constructs || size > 999) {
3200      return nok(code);
3201    }
3202    if (code === 93) {
3203      effects.exit(stringType);
3204      effects.enter(markerType);
3205      effects.consume(code);
3206      effects.exit(markerType);
3207      effects.exit(type);
3208      return ok;
3209    }
3210    if (markdownLineEnding(code)) {
3211      effects.enter("lineEnding");
3212      effects.consume(code);
3213      effects.exit("lineEnding");
3214      return atBreak;
3215    }
3216    effects.enter("chunkString", {
3217      contentType: "string"
3218    });
3219    return label(code);
3220  }
3221  function label(code) {
3222    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {
3223      effects.exit("chunkString");
3224      return atBreak(code);
3225    }
3226    effects.consume(code);
3227    data = data || !markdownSpace(code);
3228    return code === 92 ? labelEscape : label;
3229  }
3230  function labelEscape(code) {
3231    if (code === 91 || code === 92 || code === 93) {
3232      effects.consume(code);
3233      size++;
3234      return label;
3235    }
3236    return label(code);
3237  }
3238}
3239module.exports = labelFactory;
3240
3241
3242/***/ },
3243
3244/***/ 42145
3245(module, __unused_webpack_exports, __webpack_require__) {
3246
3247"use strict";
3248
3249var markdownSpace = __webpack_require__(24248);
3250function spaceFactory(effects, ok, type, max) {
3251  var limit = max ? max - 1 : Infinity;
3252  var size = 0;
3253  return start;
3254  function start(code) {
3255    if (markdownSpace(code)) {
3256      effects.enter(type);
3257      return prefix(code);
3258    }
3259    return ok(code);
3260  }
3261  function prefix(code) {
3262    if (markdownSpace(code) && size++ < limit) {
3263      effects.consume(code);
3264      return prefix;
3265    }
3266    effects.exit(type);
3267    return ok(code);
3268  }
3269}
3270module.exports = spaceFactory;
3271
3272
3273/***/ },
3274
3275/***/ 47065
3276(module, __unused_webpack_exports, __webpack_require__) {
3277
3278"use strict";
3279
3280var markdownLineEnding = __webpack_require__(63336);
3281var factorySpace = __webpack_require__(42145);
3282function titleFactory(effects, ok, nok, type, markerType, stringType) {
3283  var marker;
3284  return start;
3285  function start(code) {
3286    effects.enter(type);
3287    effects.enter(markerType);
3288    effects.consume(code);
3289    effects.exit(markerType);
3290    marker = code === 40 ? 41 : code;
3291    return atFirstTitleBreak;
3292  }
3293  function atFirstTitleBreak(code) {
3294    if (code === marker) {
3295      effects.enter(markerType);
3296      effects.consume(code);
3297      effects.exit(markerType);
3298      effects.exit(type);
3299      return ok;
3300    }
3301    effects.enter(stringType);
3302    return atTitleBreak(code);
3303  }
3304  function atTitleBreak(code) {
3305    if (code === marker) {
3306      effects.exit(stringType);
3307      return atFirstTitleBreak(marker);
3308    }
3309    if (code === null) {
3310      return nok(code);
3311    }
3312    if (markdownLineEnding(code)) {
3313      effects.enter("lineEnding");
3314      effects.consume(code);
3315      effects.exit("lineEnding");
3316      return factorySpace(effects, atTitleBreak, "linePrefix");
3317    }
3318    effects.enter("chunkString", {
3319      contentType: "string"
3320    });
3321    return title(code);
3322  }
3323  function title(code) {
3324    if (code === marker || code === null || markdownLineEnding(code)) {
3325      effects.exit("chunkString");
3326      return atTitleBreak(code);
3327    }
3328    effects.consume(code);
3329    return code === 92 ? titleEscape : title;
3330  }
3331  function titleEscape(code) {
3332    if (code === marker || code === 92) {
3333      effects.consume(code);
3334      return title;
3335    }
3336    return title(code);
3337  }
3338}
3339module.exports = titleFactory;
3340
3341
3342/***/ },
3343
3344/***/ 69726
3345(module, __unused_webpack_exports, __webpack_require__) {
3346
3347"use strict";
3348
3349var markdownLineEnding = __webpack_require__(63336);
3350var markdownSpace = __webpack_require__(24248);
3351var factorySpace = __webpack_require__(42145);
3352function whitespaceFactory(effects, ok) {
3353  var seen;
3354  return start;
3355  function start(code) {
3356    if (markdownLineEnding(code)) {
3357      effects.enter("lineEnding");
3358      effects.consume(code);
3359      effects.exit("lineEnding");
3360      seen = true;
3361      return start;
3362    }
3363    if (markdownSpace(code)) {
3364      return factorySpace(
3365        effects,
3366        start,
3367        seen ? "linePrefix" : "lineSuffix"
3368      )(code);
3369    }
3370    return ok(code);
3371  }
3372}
3373module.exports = whitespaceFactory;
3374
3375
3376/***/ },
3377
3378/***/ 95341
3379(module, __unused_webpack_exports, __webpack_require__) {
3380
3381"use strict";
3382
3383var markdownLineEnding = __webpack_require__(63336);
3384var hardBreakEscape = {
3385  name: "hardBreakEscape",
3386  tokenize: tokenizeHardBreakEscape
3387};
3388function tokenizeHardBreakEscape(effects, ok, nok) {
3389  return start;
3390  function start(code) {
3391    effects.enter("hardBreakEscape");
3392    effects.enter("escapeMarker");
3393    effects.consume(code);
3394    return open;
3395  }
3396  function open(code) {
3397    if (markdownLineEnding(code)) {
3398      effects.exit("escapeMarker");
3399      effects.exit("hardBreakEscape");
3400      return ok(code);
3401    }
3402    return nok(code);
3403  }
3404}
3405module.exports = hardBreakEscape;
3406
3407
3408/***/ },
3409
3410/***/ 26628
3411(module, __unused_webpack_exports, __webpack_require__) {
3412
3413"use strict";
3414
3415var markdownLineEnding = __webpack_require__(63336);
3416var markdownLineEndingOrSpace = __webpack_require__(2575);
3417var markdownSpace = __webpack_require__(24248);
3418var chunkedSplice = __webpack_require__(50638);
3419var factorySpace = __webpack_require__(42145);
3420var headingAtx = {
3421  name: "headingAtx",
3422  tokenize: tokenizeHeadingAtx,
3423  resolve: resolveHeadingAtx
3424};
3425function resolveHeadingAtx(events, context) {
3426  var contentEnd = events.length - 2;
3427  var contentStart = 3;
3428  var content;
3429  var text;
3430  if (events[contentStart][1].type === "whitespace") {
3431    contentStart += 2;
3432  }
3433  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") {
3434    contentEnd -= 2;
3435  }
3436  if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) {
3437    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
3438  }
3439  if (contentEnd > contentStart) {
3440    content = {
3441      type: "atxHeadingText",
3442      start: events[contentStart][1].start,
3443      end: events[contentEnd][1].end
3444    };
3445    text = {
3446      type: "chunkText",
3447      start: events[contentStart][1].start,
3448      end: events[contentEnd][1].end,
3449      contentType: "text"
3450    };
3451    chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [
3452      ["enter", content, context],
3453      ["enter", text, context],
3454      ["exit", text, context],
3455      ["exit", content, context]
3456    ]);
3457  }
3458  return events;
3459}
3460function tokenizeHeadingAtx(effects, ok, nok) {
3461  var self = this;
3462  var size = 0;
3463  return start;
3464  function start(code) {
3465    effects.enter("atxHeading");
3466    effects.enter("atxHeadingSequence");
3467    return fenceOpenInside(code);
3468  }
3469  function fenceOpenInside(code) {
3470    if (code === 35 && size++ < 6) {
3471      effects.consume(code);
3472      return fenceOpenInside;
3473    }
3474    if (code === null || markdownLineEndingOrSpace(code)) {
3475      effects.exit("atxHeadingSequence");
3476      return self.interrupt ? ok(code) : headingBreak(code);
3477    }
3478    return nok(code);
3479  }
3480  function headingBreak(code) {
3481    if (code === 35) {
3482      effects.enter("atxHeadingSequence");
3483      return sequence(code);
3484    }
3485    if (code === null || markdownLineEnding(code)) {
3486      effects.exit("atxHeading");
3487      return ok(code);
3488    }
3489    if (markdownSpace(code)) {
3490      return factorySpace(effects, headingBreak, "whitespace")(code);
3491    }
3492    effects.enter("atxHeadingText");
3493    return data(code);
3494  }
3495  function sequence(code) {
3496    if (code === 35) {
3497      effects.consume(code);
3498      return sequence;
3499    }
3500    effects.exit("atxHeadingSequence");
3501    return headingBreak(code);
3502  }
3503  function data(code) {
3504    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
3505      effects.exit("atxHeadingText");
3506      return headingBreak(code);
3507    }
3508    effects.consume(code);
3509    return data;
3510  }
3511}
3512module.exports = headingAtx;
3513
3514
3515/***/ },
3516
3517/***/ 98272
3518(module, __unused_webpack_exports, __webpack_require__) {
3519
3520"use strict";
3521
3522var asciiAlpha = __webpack_require__(40558);
3523var asciiAlphanumeric = __webpack_require__(88567);
3524var markdownLineEnding = __webpack_require__(63336);
3525var markdownLineEndingOrSpace = __webpack_require__(2575);
3526var markdownSpace = __webpack_require__(24248);
3527var fromCharCode = __webpack_require__(86778);
3528var htmlBlockNames = __webpack_require__(84809);
3529var htmlRawNames = __webpack_require__(89558);
3530var partialBlankLine = __webpack_require__(89177);
3531var htmlFlow = {
3532  name: "htmlFlow",
3533  tokenize: tokenizeHtmlFlow,
3534  resolveTo: resolveToHtmlFlow,
3535  concrete: true
3536};
3537var nextBlankConstruct = {
3538  tokenize: tokenizeNextBlank,
3539  partial: true
3540};
3541function resolveToHtmlFlow(events) {
3542  var index = events.length;
3543  while (index--) {
3544    if (events[index][0] === "enter" && events[index][1].type === "htmlFlow") {
3545      break;
3546    }
3547  }
3548  if (index > 1 && events[index - 2][1].type === "linePrefix") {
3549    events[index][1].start = events[index - 2][1].start;
3550    events[index + 1][1].start = events[index - 2][1].start;
3551    events.splice(index - 2, 2);
3552  }
3553  return events;
3554}
3555function tokenizeHtmlFlow(effects, ok, nok) {
3556  var self = this;
3557  var kind;
3558  var startTag;
3559  var buffer;
3560  var index;
3561  var marker;
3562  return start;
3563  function start(code) {
3564    effects.enter("htmlFlow");
3565    effects.enter("htmlFlowData");
3566    effects.consume(code);
3567    return open;
3568  }
3569  function open(code) {
3570    if (code === 33) {
3571      effects.consume(code);
3572      return declarationStart;
3573    }
3574    if (code === 47) {
3575      effects.consume(code);
3576      return tagCloseStart;
3577    }
3578    if (code === 63) {
3579      effects.consume(code);
3580      kind = 3;
3581      return self.interrupt ? ok : continuationDeclarationInside;
3582    }
3583    if (asciiAlpha(code)) {
3584      effects.consume(code);
3585      buffer = fromCharCode(code);
3586      startTag = true;
3587      return tagName;
3588    }
3589    return nok(code);
3590  }
3591  function declarationStart(code) {
3592    if (code === 45) {
3593      effects.consume(code);
3594      kind = 2;
3595      return commentOpenInside;
3596    }
3597    if (code === 91) {
3598      effects.consume(code);
3599      kind = 5;
3600      buffer = "CDATA[";
3601      index = 0;
3602      return cdataOpenInside;
3603    }
3604    if (asciiAlpha(code)) {
3605      effects.consume(code);
3606      kind = 4;
3607      return self.interrupt ? ok : continuationDeclarationInside;
3608    }
3609    return nok(code);
3610  }
3611  function commentOpenInside(code) {
3612    if (code === 45) {
3613      effects.consume(code);
3614      return self.interrupt ? ok : continuationDeclarationInside;
3615    }
3616    return nok(code);
3617  }
3618  function cdataOpenInside(code) {
3619    if (code === buffer.charCodeAt(index++)) {
3620      effects.consume(code);
3621      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;
3622    }
3623    return nok(code);
3624  }
3625  function tagCloseStart(code) {
3626    if (asciiAlpha(code)) {
3627      effects.consume(code);
3628      buffer = fromCharCode(code);
3629      return tagName;
3630    }
3631    return nok(code);
3632  }
3633  function tagName(code) {
3634    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
3635      if (code !== 47 && startTag && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {
3636        kind = 1;
3637        return self.interrupt ? ok(code) : continuation(code);
3638      }
3639      if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {
3640        kind = 6;
3641        if (code === 47) {
3642          effects.consume(code);
3643          return basicSelfClosing;
3644        }
3645        return self.interrupt ? ok(code) : continuation(code);
3646      }
3647      kind = 7;
3648      return self.interrupt ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);
3649    }
3650    if (code === 45 || asciiAlphanumeric(code)) {
3651      effects.consume(code);
3652      buffer += fromCharCode(code);
3653      return tagName;
3654    }
3655    return nok(code);
3656  }
3657  function basicSelfClosing(code) {
3658    if (code === 62) {
3659      effects.consume(code);
3660      return self.interrupt ? ok : continuation;
3661    }
3662    return nok(code);
3663  }
3664  function completeClosingTagAfter(code) {
3665    if (markdownSpace(code)) {
3666      effects.consume(code);
3667      return completeClosingTagAfter;
3668    }
3669    return completeEnd(code);
3670  }
3671  function completeAttributeNameBefore(code) {
3672    if (code === 47) {
3673      effects.consume(code);
3674      return completeEnd;
3675    }
3676    if (code === 58 || code === 95 || asciiAlpha(code)) {
3677      effects.consume(code);
3678      return completeAttributeName;
3679    }
3680    if (markdownSpace(code)) {
3681      effects.consume(code);
3682      return completeAttributeNameBefore;
3683    }
3684    return completeEnd(code);
3685  }
3686  function completeAttributeName(code) {
3687    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {
3688      effects.consume(code);
3689      return completeAttributeName;
3690    }
3691    return completeAttributeNameAfter(code);
3692  }
3693  function completeAttributeNameAfter(code) {
3694    if (code === 61) {
3695      effects.consume(code);
3696      return completeAttributeValueBefore;
3697    }
3698    if (markdownSpace(code)) {
3699      effects.consume(code);
3700      return completeAttributeNameAfter;
3701    }
3702    return completeAttributeNameBefore(code);
3703  }
3704  function completeAttributeValueBefore(code) {
3705    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {
3706      return nok(code);
3707    }
3708    if (code === 34 || code === 39) {
3709      effects.consume(code);
3710      marker = code;
3711      return completeAttributeValueQuoted;
3712    }
3713    if (markdownSpace(code)) {
3714      effects.consume(code);
3715      return completeAttributeValueBefore;
3716    }
3717    marker = void 0;
3718    return completeAttributeValueUnquoted(code);
3719  }
3720  function completeAttributeValueQuoted(code) {
3721    if (code === marker) {
3722      effects.consume(code);
3723      return completeAttributeValueQuotedAfter;
3724    }
3725    if (code === null || markdownLineEnding(code)) {
3726      return nok(code);
3727    }
3728    effects.consume(code);
3729    return completeAttributeValueQuoted;
3730  }
3731  function completeAttributeValueUnquoted(code) {
3732    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {
3733      return completeAttributeNameAfter(code);
3734    }
3735    effects.consume(code);
3736    return completeAttributeValueUnquoted;
3737  }
3738  function completeAttributeValueQuotedAfter(code) {
3739    if (code === 47 || code === 62 || markdownSpace(code)) {
3740      return completeAttributeNameBefore(code);
3741    }
3742    return nok(code);
3743  }
3744  function completeEnd(code) {
3745    if (code === 62) {
3746      effects.consume(code);
3747      return completeAfter;
3748    }
3749    return nok(code);
3750  }
3751  function completeAfter(code) {
3752    if (markdownSpace(code)) {
3753      effects.consume(code);
3754      return completeAfter;
3755    }
3756    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);
3757  }
3758  function continuation(code) {
3759    if (code === 45 && kind === 2) {
3760      effects.consume(code);
3761      return continuationCommentInside;
3762    }
3763    if (code === 60 && kind === 1) {
3764      effects.consume(code);
3765      return continuationRawTagOpen;
3766    }
3767    if (code === 62 && kind === 4) {
3768      effects.consume(code);
3769      return continuationClose;
3770    }
3771    if (code === 63 && kind === 3) {
3772      effects.consume(code);
3773      return continuationDeclarationInside;
3774    }
3775    if (code === 93 && kind === 5) {
3776      effects.consume(code);
3777      return continuationCharacterDataInside;
3778    }
3779    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {
3780      return effects.check(
3781        nextBlankConstruct,
3782        continuationClose,
3783        continuationAtLineEnding
3784      )(code);
3785    }
3786    if (code === null || markdownLineEnding(code)) {
3787      return continuationAtLineEnding(code);
3788    }
3789    effects.consume(code);
3790    return continuation;
3791  }
3792  function continuationAtLineEnding(code) {
3793    effects.exit("htmlFlowData");
3794    return htmlContinueStart(code);
3795  }
3796  function htmlContinueStart(code) {
3797    if (code === null) {
3798      return done(code);
3799    }
3800    if (markdownLineEnding(code)) {
3801      effects.enter("lineEnding");
3802      effects.consume(code);
3803      effects.exit("lineEnding");
3804      return htmlContinueStart;
3805    }
3806    effects.enter("htmlFlowData");
3807    return continuation(code);
3808  }
3809  function continuationCommentInside(code) {
3810    if (code === 45) {
3811      effects.consume(code);
3812      return continuationDeclarationInside;
3813    }
3814    return continuation(code);
3815  }
3816  function continuationRawTagOpen(code) {
3817    if (code === 47) {
3818      effects.consume(code);
3819      buffer = "";
3820      return continuationRawEndTag;
3821    }
3822    return continuation(code);
3823  }
3824  function continuationRawEndTag(code) {
3825    if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {
3826      effects.consume(code);
3827      return continuationClose;
3828    }
3829    if (asciiAlpha(code) && buffer.length < 8) {
3830      effects.consume(code);
3831      buffer += fromCharCode(code);
3832      return continuationRawEndTag;
3833    }
3834    return continuation(code);
3835  }
3836  function continuationCharacterDataInside(code) {
3837    if (code === 93) {
3838      effects.consume(code);
3839      return continuationDeclarationInside;
3840    }
3841    return continuation(code);
3842  }
3843  function continuationDeclarationInside(code) {
3844    if (code === 62) {
3845      effects.consume(code);
3846      return continuationClose;
3847    }
3848    return continuation(code);
3849  }
3850  function continuationClose(code) {
3851    if (code === null || markdownLineEnding(code)) {
3852      effects.exit("htmlFlowData");
3853      return done(code);
3854    }
3855    effects.consume(code);
3856    return continuationClose;
3857  }
3858  function done(code) {
3859    effects.exit("htmlFlow");
3860    return ok(code);
3861  }
3862}
3863function tokenizeNextBlank(effects, ok, nok) {
3864  return start;
3865  function start(code) {
3866    effects.exit("htmlFlowData");
3867    effects.enter("lineEndingBlank");
3868    effects.consume(code);
3869    effects.exit("lineEndingBlank");
3870    return effects.attempt(partialBlankLine, ok, nok);
3871  }
3872}
3873module.exports = htmlFlow;
3874
3875
3876/***/ },
3877
3878/***/ 75775
3879(module, __unused_webpack_exports, __webpack_require__) {
3880
3881"use strict";
3882
3883var asciiAlpha = __webpack_require__(40558);
3884var asciiAlphanumeric = __webpack_require__(88567);
3885var markdownLineEnding = __webpack_require__(63336);
3886var markdownLineEndingOrSpace = __webpack_require__(2575);
3887var markdownSpace = __webpack_require__(24248);
3888var factorySpace = __webpack_require__(42145);
3889var htmlText = {
3890  name: "htmlText",
3891  tokenize: tokenizeHtmlText
3892};
3893function tokenizeHtmlText(effects, ok, nok) {
3894  var self = this;
3895  var marker;
3896  var buffer;
3897  var index;
3898  var returnState;
3899  return start;
3900  function start(code) {
3901    effects.enter("htmlText");
3902    effects.enter("htmlTextData");
3903    effects.consume(code);
3904    return open;
3905  }
3906  function open(code) {
3907    if (code === 33) {
3908      effects.consume(code);
3909      return declarationOpen;
3910    }
3911    if (code === 47) {
3912      effects.consume(code);
3913      return tagCloseStart;
3914    }
3915    if (code === 63) {
3916      effects.consume(code);
3917      return instruction;
3918    }
3919    if (asciiAlpha(code)) {
3920      effects.consume(code);
3921      return tagOpen;
3922    }
3923    return nok(code);
3924  }
3925  function declarationOpen(code) {
3926    if (code === 45) {
3927      effects.consume(code);
3928      return commentOpen;
3929    }
3930    if (code === 91) {
3931      effects.consume(code);
3932      buffer = "CDATA[";
3933      index = 0;
3934      return cdataOpen;
3935    }
3936    if (asciiAlpha(code)) {
3937      effects.consume(code);
3938      return declaration;
3939    }
3940    return nok(code);
3941  }
3942  function commentOpen(code) {
3943    if (code === 45) {
3944      effects.consume(code);
3945      return commentStart;
3946    }
3947    return nok(code);
3948  }
3949  function commentStart(code) {
3950    if (code === null || code === 62) {
3951      return nok(code);
3952    }
3953    if (code === 45) {
3954      effects.consume(code);
3955      return commentStartDash;
3956    }
3957    return comment(code);
3958  }
3959  function commentStartDash(code) {
3960    if (code === null || code === 62) {
3961      return nok(code);
3962    }
3963    return comment(code);
3964  }
3965  function comment(code) {
3966    if (code === null) {
3967      return nok(code);
3968    }
3969    if (code === 45) {
3970      effects.consume(code);
3971      return commentClose;
3972    }
3973    if (markdownLineEnding(code)) {
3974      returnState = comment;
3975      return atLineEnding(code);
3976    }
3977    effects.consume(code);
3978    return comment;
3979  }
3980  function commentClose(code) {
3981    if (code === 45) {
3982      effects.consume(code);
3983      return end;
3984    }
3985    return comment(code);
3986  }
3987  function cdataOpen(code) {
3988    if (code === buffer.charCodeAt(index++)) {
3989      effects.consume(code);
3990      return index === buffer.length ? cdata : cdataOpen;
3991    }
3992    return nok(code);
3993  }
3994  function cdata(code) {
3995    if (code === null) {
3996      return nok(code);
3997    }
3998    if (code === 93) {
3999      effects.consume(code);
4000      return cdataClose;
4001    }
4002    if (markdownLineEnding(code)) {
4003      returnState = cdata;
4004      return atLineEnding(code);
4005    }
4006    effects.consume(code);
4007    return cdata;
4008  }
4009  function cdataClose(code) {
4010    if (code === 93) {
4011      effects.consume(code);
4012      return cdataEnd;
4013    }
4014    return cdata(code);
4015  }
4016  function cdataEnd(code) {
4017    if (code === 62) {
4018      return end(code);
4019    }
4020    if (code === 93) {
4021      effects.consume(code);
4022      return cdataEnd;
4023    }
4024    return cdata(code);
4025  }
4026  function declaration(code) {
4027    if (code === null || code === 62) {
4028      return end(code);
4029    }
4030    if (markdownLineEnding(code)) {
4031      returnState = declaration;
4032      return atLineEnding(code);
4033    }
4034    effects.consume(code);
4035    return declaration;
4036  }
4037  function instruction(code) {
4038    if (code === null) {
4039      return nok(code);
4040    }
4041    if (code === 63) {
4042      effects.consume(code);
4043      return instructionClose;
4044    }
4045    if (markdownLineEnding(code)) {
4046      returnState = instruction;
4047      return atLineEnding(code);
4048    }
4049    effects.consume(code);
4050    return instruction;
4051  }
4052  function instructionClose(code) {
4053    return code === 62 ? end(code) : instruction(code);
4054  }
4055  function tagCloseStart(code) {
4056    if (asciiAlpha(code)) {
4057      effects.consume(code);
4058      return tagClose;
4059    }
4060    return nok(code);
4061  }
4062  function tagClose(code) {
4063    if (code === 45 || asciiAlphanumeric(code)) {
4064      effects.consume(code);
4065      return tagClose;
4066    }
4067    return tagCloseBetween(code);
4068  }
4069  function tagCloseBetween(code) {
4070    if (markdownLineEnding(code)) {
4071      returnState = tagCloseBetween;
4072      return atLineEnding(code);
4073    }
4074    if (markdownSpace(code)) {
4075      effects.consume(code);
4076      return tagCloseBetween;
4077    }
4078    return end(code);
4079  }
4080  function tagOpen(code) {
4081    if (code === 45 || asciiAlphanumeric(code)) {
4082      effects.consume(code);
4083      return tagOpen;
4084    }
4085    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
4086      return tagOpenBetween(code);
4087    }
4088    return nok(code);
4089  }
4090  function tagOpenBetween(code) {
4091    if (code === 47) {
4092      effects.consume(code);
4093      return end;
4094    }
4095    if (code === 58 || code === 95 || asciiAlpha(code)) {
4096      effects.consume(code);
4097      return tagOpenAttributeName;
4098    }
4099    if (markdownLineEnding(code)) {
4100      returnState = tagOpenBetween;
4101      return atLineEnding(code);
4102    }
4103    if (markdownSpace(code)) {
4104      effects.consume(code);
4105      return tagOpenBetween;
4106    }
4107    return end(code);
4108  }
4109  function tagOpenAttributeName(code) {
4110    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {
4111      effects.consume(code);
4112      return tagOpenAttributeName;
4113    }
4114    return tagOpenAttributeNameAfter(code);
4115  }
4116  function tagOpenAttributeNameAfter(code) {
4117    if (code === 61) {
4118      effects.consume(code);
4119      return tagOpenAttributeValueBefore;
4120    }
4121    if (markdownLineEnding(code)) {
4122      returnState = tagOpenAttributeNameAfter;
4123      return atLineEnding(code);
4124    }
4125    if (markdownSpace(code)) {
4126      effects.consume(code);
4127      return tagOpenAttributeNameAfter;
4128    }
4129    return tagOpenBetween(code);
4130  }
4131  function tagOpenAttributeValueBefore(code) {
4132    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {
4133      return nok(code);
4134    }
4135    if (code === 34 || code === 39) {
4136      effects.consume(code);
4137      marker = code;
4138      return tagOpenAttributeValueQuoted;
4139    }
4140    if (markdownLineEnding(code)) {
4141      returnState = tagOpenAttributeValueBefore;
4142      return atLineEnding(code);
4143    }
4144    if (markdownSpace(code)) {
4145      effects.consume(code);
4146      return tagOpenAttributeValueBefore;
4147    }
4148    effects.consume(code);
4149    marker = void 0;
4150    return tagOpenAttributeValueUnquoted;
4151  }
4152  function tagOpenAttributeValueQuoted(code) {
4153    if (code === marker) {
4154      effects.consume(code);
4155      return tagOpenAttributeValueQuotedAfter;
4156    }
4157    if (code === null) {
4158      return nok(code);
4159    }
4160    if (markdownLineEnding(code)) {
4161      returnState = tagOpenAttributeValueQuoted;
4162      return atLineEnding(code);
4163    }
4164    effects.consume(code);
4165    return tagOpenAttributeValueQuoted;
4166  }
4167  function tagOpenAttributeValueQuotedAfter(code) {
4168    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {
4169      return tagOpenBetween(code);
4170    }
4171    return nok(code);
4172  }
4173  function tagOpenAttributeValueUnquoted(code) {
4174    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {
4175      return nok(code);
4176    }
4177    if (code === 62 || markdownLineEndingOrSpace(code)) {
4178      return tagOpenBetween(code);
4179    }
4180    effects.consume(code);
4181    return tagOpenAttributeValueUnquoted;
4182  }
4183  function atLineEnding(code) {
4184    effects.exit("htmlTextData");
4185    effects.enter("lineEnding");
4186    effects.consume(code);
4187    effects.exit("lineEnding");
4188    return factorySpace(
4189      effects,
4190      afterPrefix,
4191      "linePrefix",
4192      self.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4
4193    );
4194  }
4195  function afterPrefix(code) {
4196    effects.enter("htmlTextData");
4197    return returnState(code);
4198  }
4199  function end(code) {
4200    if (code === 62) {
4201      effects.consume(code);
4202      effects.exit("htmlTextData");
4203      effects.exit("htmlText");
4204      return ok;
4205    }
4206    return nok(code);
4207  }
4208}
4209module.exports = htmlText;
4210
4211
4212/***/ },
4213
4214/***/ 63734
4215(module, __unused_webpack_exports, __webpack_require__) {
4216
4217"use strict";
4218
4219var markdownLineEndingOrSpace = __webpack_require__(2575);
4220var chunkedPush = __webpack_require__(90638);
4221var chunkedSplice = __webpack_require__(50638);
4222var normalizeIdentifier = __webpack_require__(17904);
4223var resolveAll = __webpack_require__(33399);
4224var shallow = __webpack_require__(34645);
4225var factoryDestination = __webpack_require__(53263);
4226var factoryLabel = __webpack_require__(27465);
4227var factoryTitle = __webpack_require__(47065);
4228var factoryWhitespace = __webpack_require__(69726);
4229var labelEnd = {
4230  name: "labelEnd",
4231  tokenize: tokenizeLabelEnd,
4232  resolveTo: resolveToLabelEnd,
4233  resolveAll: resolveAllLabelEnd
4234};
4235var resourceConstruct = {
4236  tokenize: tokenizeResource
4237};
4238var fullReferenceConstruct = {
4239  tokenize: tokenizeFullReference
4240};
4241var collapsedReferenceConstruct = {
4242  tokenize: tokenizeCollapsedReference
4243};
4244function resolveAllLabelEnd(events) {
4245  var index = -1;
4246  var token;
4247  while (++index < events.length) {
4248    token = events[index][1];
4249    if (!token._used && (token.type === "labelImage" || token.type === "labelLink" || token.type === "labelEnd")) {
4250      events.splice(index + 1, token.type === "labelImage" ? 4 : 2);
4251      token.type = "data";
4252      index++;
4253    }
4254  }
4255  return events;
4256}
4257function resolveToLabelEnd(events, context) {
4258  var index = events.length;
4259  var offset = 0;
4260  var group;
4261  var label;
4262  var text;
4263  var token;
4264  var open;
4265  var close;
4266  var media;
4267  while (index--) {
4268    token = events[index][1];
4269    if (open) {
4270      if (token.type === "link" || token.type === "labelLink" && token._inactive) {
4271        break;
4272      }
4273      if (events[index][0] === "enter" && token.type === "labelLink") {
4274        token._inactive = true;
4275      }
4276    } else if (close) {
4277      if (events[index][0] === "enter" && (token.type === "labelImage" || token.type === "labelLink") && !token._balanced) {
4278        open = index;
4279        if (token.type !== "labelLink") {
4280          offset = 2;
4281          break;
4282        }
4283      }
4284    } else if (token.type === "labelEnd") {
4285      close = index;
4286    }
4287  }
4288  group = {
4289    type: events[open][1].type === "labelLink" ? "link" : "image",
4290    start: shallow(events[open][1].start),
4291    end: shallow(events[events.length - 1][1].end)
4292  };
4293  label = {
4294    type: "label",
4295    start: shallow(events[open][1].start),
4296    end: shallow(events[close][1].end)
4297  };
4298  text = {
4299    type: "labelText",
4300    start: shallow(events[open + offset + 2][1].end),
4301    end: shallow(events[close - 2][1].start)
4302  };
4303  media = [
4304    ["enter", group, context],
4305    ["enter", label, context]
4306  ];
4307  media = chunkedPush(media, events.slice(open + 1, open + offset + 3));
4308  media = chunkedPush(media, [["enter", text, context]]);
4309  media = chunkedPush(
4310    media,
4311    resolveAll(
4312      context.parser.constructs.insideSpan.null,
4313      events.slice(open + offset + 4, close - 3),
4314      context
4315    )
4316  );
4317  media = chunkedPush(media, [
4318    ["exit", text, context],
4319    events[close - 2],
4320    events[close - 1],
4321    ["exit", label, context]
4322  ]);
4323  media = chunkedPush(media, events.slice(close + 1));
4324  media = chunkedPush(media, [["exit", group, context]]);
4325  chunkedSplice(events, open, events.length, media);
4326  return events;
4327}
4328function tokenizeLabelEnd(effects, ok, nok) {
4329  var self = this;
4330  var index = self.events.length;
4331  var labelStart;
4332  var defined;
4333  while (index--) {
4334    if ((self.events[index][1].type === "labelImage" || self.events[index][1].type === "labelLink") && !self.events[index][1]._balanced) {
4335      labelStart = self.events[index][1];
4336      break;
4337    }
4338  }
4339  return start;
4340  function start(code) {
4341    if (!labelStart) {
4342      return nok(code);
4343    }
4344    if (labelStart._inactive) return balanced(code);
4345    defined = self.parser.defined.indexOf(
4346      normalizeIdentifier(
4347        self.sliceSerialize({
4348          start: labelStart.end,
4349          end: self.now()
4350        })
4351      )
4352    ) > -1;
4353    effects.enter("labelEnd");
4354    effects.enter("labelMarker");
4355    effects.consume(code);
4356    effects.exit("labelMarker");
4357    effects.exit("labelEnd");
4358    return afterLabelEnd;
4359  }
4360  function afterLabelEnd(code) {
4361    if (code === 40) {
4362      return effects.attempt(
4363        resourceConstruct,
4364        ok,
4365        defined ? ok : balanced
4366      )(code);
4367    }
4368    if (code === 91) {
4369      return effects.attempt(
4370        fullReferenceConstruct,
4371        ok,
4372        defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced
4373      )(code);
4374    }
4375    return defined ? ok(code) : balanced(code);
4376  }
4377  function balanced(code) {
4378    labelStart._balanced = true;
4379    return nok(code);
4380  }
4381}
4382function tokenizeResource(effects, ok, nok) {
4383  return start;
4384  function start(code) {
4385    effects.enter("resource");
4386    effects.enter("resourceMarker");
4387    effects.consume(code);
4388    effects.exit("resourceMarker");
4389    return factoryWhitespace(effects, open);
4390  }
4391  function open(code) {
4392    if (code === 41) {
4393      return end(code);
4394    }
4395    return factoryDestination(
4396      effects,
4397      destinationAfter,
4398      nok,
4399      "resourceDestination",
4400      "resourceDestinationLiteral",
4401      "resourceDestinationLiteralMarker",
4402      "resourceDestinationRaw",
4403      "resourceDestinationString",
4404      3
4405    )(code);
4406  }
4407  function destinationAfter(code) {
4408    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);
4409  }
4410  function between(code) {
4411    if (code === 34 || code === 39 || code === 40) {
4412      return factoryTitle(
4413        effects,
4414        factoryWhitespace(effects, end),
4415        nok,
4416        "resourceTitle",
4417        "resourceTitleMarker",
4418        "resourceTitleString"
4419      )(code);
4420    }
4421    return end(code);
4422  }
4423  function end(code) {
4424    if (code === 41) {
4425      effects.enter("resourceMarker");
4426      effects.consume(code);
4427      effects.exit("resourceMarker");
4428      effects.exit("resource");
4429      return ok;
4430    }
4431    return nok(code);
4432  }
4433}
4434function tokenizeFullReference(effects, ok, nok) {
4435  var self = this;
4436  return start;
4437  function start(code) {
4438    return factoryLabel.call(
4439      self,
4440      effects,
4441      afterLabel,
4442      nok,
4443      "reference",
4444      "referenceMarker",
4445      "referenceString"
4446    )(code);
4447  }
4448  function afterLabel(code) {
4449    return self.parser.defined.indexOf(
4450      normalizeIdentifier(
4451        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
4452      )
4453    ) < 0 ? nok(code) : ok(code);
4454  }
4455}
4456function tokenizeCollapsedReference(effects, ok, nok) {
4457  return start;
4458  function start(code) {
4459    effects.enter("reference");
4460    effects.enter("referenceMarker");
4461    effects.consume(code);
4462    effects.exit("referenceMarker");
4463    return open;
4464  }
4465  function open(code) {
4466    if (code === 93) {
4467      effects.enter("referenceMarker");
4468      effects.consume(code);
4469      effects.exit("referenceMarker");
4470      effects.exit("reference");
4471      return ok;
4472    }
4473    return nok(code);
4474  }
4475}
4476module.exports = labelEnd;
4477
4478
4479/***/ },
4480
4481/***/ 98543
4482(module, __unused_webpack_exports, __webpack_require__) {
4483
4484"use strict";
4485
4486var labelEnd = __webpack_require__(63734);
4487var labelStartImage = {
4488  name: "labelStartImage",
4489  tokenize: tokenizeLabelStartImage,
4490  resolveAll: labelEnd.resolveAll
4491};
4492function tokenizeLabelStartImage(effects, ok, nok) {
4493  var self = this;
4494  return start;
4495  function start(code) {
4496    effects.enter("labelImage");
4497    effects.enter("labelImageMarker");
4498    effects.consume(code);
4499    effects.exit("labelImageMarker");
4500    return open;
4501  }
4502  function open(code) {
4503    if (code === 91) {
4504      effects.enter("labelMarker");
4505      effects.consume(code);
4506      effects.exit("labelMarker");
4507      effects.exit("labelImage");
4508      return after;
4509    }
4510    return nok(code);
4511  }
4512  function after(code) {
4513    return code === 94 && /* c8 ignore next */
4514    "_hiddenFootnoteSupport" in self.parser.constructs ? (
4515      /* c8 ignore next */
4516      nok(code)
4517    ) : ok(code);
4518  }
4519}
4520module.exports = labelStartImage;
4521
4522
4523/***/ },
4524
4525/***/ 87196
4526(module, __unused_webpack_exports, __webpack_require__) {
4527
4528"use strict";
4529
4530var labelEnd = __webpack_require__(63734);
4531var labelStartLink = {
4532  name: "labelStartLink",
4533  tokenize: tokenizeLabelStartLink,
4534  resolveAll: labelEnd.resolveAll
4535};
4536function tokenizeLabelStartLink(effects, ok, nok) {
4537  var self = this;
4538  return start;
4539  function start(code) {
4540    effects.enter("labelLink");
4541    effects.enter("labelMarker");
4542    effects.consume(code);
4543    effects.exit("labelMarker");
4544    effects.exit("labelLink");
4545    return after;
4546  }
4547  function after(code) {
4548    return code === 94 && /* c8 ignore next */
4549    "_hiddenFootnoteSupport" in self.parser.constructs ? (
4550      /* c8 ignore next */
4551      nok(code)
4552    ) : ok(code);
4553  }
4554}
4555module.exports = labelStartLink;
4556
4557
4558/***/ },
4559
4560/***/ 43742
4561(module, __unused_webpack_exports, __webpack_require__) {
4562
4563"use strict";
4564
4565var factorySpace = __webpack_require__(42145);
4566var lineEnding = {
4567  name: "lineEnding",
4568  tokenize: tokenizeLineEnding
4569};
4570function tokenizeLineEnding(effects, ok) {
4571  return start;
4572  function start(code) {
4573    effects.enter("lineEnding");
4574    effects.consume(code);
4575    effects.exit("lineEnding");
4576    return factorySpace(effects, ok, "linePrefix");
4577  }
4578}
4579module.exports = lineEnding;
4580
4581
4582/***/ },
4583
4584/***/ 42666
4585(module, __unused_webpack_exports, __webpack_require__) {
4586
4587"use strict";
4588
4589var asciiDigit = __webpack_require__(58488);
4590var markdownSpace = __webpack_require__(24248);
4591var prefixSize = __webpack_require__(71795);
4592var sizeChunks = __webpack_require__(87175);
4593var factorySpace = __webpack_require__(42145);
4594var partialBlankLine = __webpack_require__(89177);
4595var thematicBreak = __webpack_require__(75911);
4596var list = {
4597  name: "list",
4598  tokenize: tokenizeListStart,
4599  continuation: {
4600    tokenize: tokenizeListContinuation
4601  },
4602  exit: tokenizeListEnd
4603};
4604var listItemPrefixWhitespaceConstruct = {
4605  tokenize: tokenizeListItemPrefixWhitespace,
4606  partial: true
4607};
4608var indentConstruct = {
4609  tokenize: tokenizeIndent,
4610  partial: true
4611};
4612function tokenizeListStart(effects, ok, nok) {
4613  var self = this;
4614  var initialSize = prefixSize(self.events, "linePrefix");
4615  var size = 0;
4616  return start;
4617  function start(code) {
4618    var kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? "listUnordered" : "listOrdered");
4619    if (kind === "listUnordered" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {
4620      if (!self.containerState.type) {
4621        self.containerState.type = kind;
4622        effects.enter(kind, {
4623          _container: true
4624        });
4625      }
4626      if (kind === "listUnordered") {
4627        effects.enter("listItemPrefix");
4628        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);
4629      }
4630      if (!self.interrupt || code === 49) {
4631        effects.enter("listItemPrefix");
4632        effects.enter("listItemValue");
4633        return inside(code);
4634      }
4635    }
4636    return nok(code);
4637  }
4638  function inside(code) {
4639    if (asciiDigit(code) && ++size < 10) {
4640      effects.consume(code);
4641      return inside;
4642    }
4643    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {
4644      effects.exit("listItemValue");
4645      return atMarker(code);
4646    }
4647    return nok(code);
4648  }
4649  function atMarker(code) {
4650    effects.enter("listItemMarker");
4651    effects.consume(code);
4652    effects.exit("listItemMarker");
4653    self.containerState.marker = self.containerState.marker || code;
4654    return effects.check(
4655      partialBlankLine,
4656      // Can’t be empty when interrupting.
4657      self.interrupt ? nok : onBlank,
4658      effects.attempt(
4659        listItemPrefixWhitespaceConstruct,
4660        endOfPrefix,
4661        otherPrefix
4662      )
4663    );
4664  }
4665  function onBlank(code) {
4666    self.containerState.initialBlankLine = true;
4667    initialSize++;
4668    return endOfPrefix(code);
4669  }
4670  function otherPrefix(code) {
4671    if (markdownSpace(code)) {
4672      effects.enter("listItemPrefixWhitespace");
4673      effects.consume(code);
4674      effects.exit("listItemPrefixWhitespace");
4675      return endOfPrefix;
4676    }
4677    return nok(code);
4678  }
4679  function endOfPrefix(code) {
4680    self.containerState.size = initialSize + sizeChunks(self.sliceStream(effects.exit("listItemPrefix")));
4681    return ok(code);
4682  }
4683}
4684function tokenizeListContinuation(effects, ok, nok) {
4685  var self = this;
4686  self.containerState._closeFlow = void 0;
4687  return effects.check(partialBlankLine, onBlank, notBlank);
4688  function onBlank(code) {
4689    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;
4690    return factorySpace(
4691      effects,
4692      ok,
4693      "listItemIndent",
4694      self.containerState.size + 1
4695    )(code);
4696  }
4697  function notBlank(code) {
4698    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
4699      self.containerState.furtherBlankLines = self.containerState.initialBlankLine = void 0;
4700      return notInCurrentItem(code);
4701    }
4702    self.containerState.furtherBlankLines = self.containerState.initialBlankLine = void 0;
4703    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);
4704  }
4705  function notInCurrentItem(code) {
4706    self.containerState._closeFlow = true;
4707    self.interrupt = void 0;
4708    return factorySpace(
4709      effects,
4710      effects.attempt(list, ok, nok),
4711      "linePrefix",
4712      self.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4
4713    )(code);
4714  }
4715}
4716function tokenizeIndent(effects, ok, nok) {
4717  var self = this;
4718  return factorySpace(
4719    effects,
4720    afterPrefix,
4721    "listItemIndent",
4722    self.containerState.size + 1
4723  );
4724  function afterPrefix(code) {
4725    return prefixSize(self.events, "listItemIndent") === self.containerState.size ? ok(code) : nok(code);
4726  }
4727}
4728function tokenizeListEnd(effects) {
4729  effects.exit(this.containerState.type);
4730}
4731function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
4732  var self = this;
4733  return factorySpace(
4734    effects,
4735    afterPrefix,
4736    "listItemPrefixWhitespace",
4737    self.parser.constructs.disable.null.indexOf("codeIndented") > -1 ? void 0 : 4 + 1
4738  );
4739  function afterPrefix(code) {
4740    return markdownSpace(code) || !prefixSize(self.events, "listItemPrefixWhitespace") ? nok(code) : ok(code);
4741  }
4742}
4743module.exports = list;
4744
4745
4746/***/ },
4747
4748/***/ 89177
4749(module, __unused_webpack_exports, __webpack_require__) {
4750
4751"use strict";
4752
4753var markdownLineEnding = __webpack_require__(63336);
4754var factorySpace = __webpack_require__(42145);
4755var partialBlankLine = {
4756  tokenize: tokenizePartialBlankLine,
4757  partial: true
4758};
4759function tokenizePartialBlankLine(effects, ok, nok) {
4760  return factorySpace(effects, afterWhitespace, "linePrefix");
4761  function afterWhitespace(code) {
4762    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
4763  }
4764}
4765module.exports = partialBlankLine;
4766
4767
4768/***/ },
4769
4770/***/ 57720
4771(module, __unused_webpack_exports, __webpack_require__) {
4772
4773"use strict";
4774
4775var markdownLineEnding = __webpack_require__(63336);
4776var shallow = __webpack_require__(34645);
4777var factorySpace = __webpack_require__(42145);
4778var setextUnderline = {
4779  name: "setextUnderline",
4780  tokenize: tokenizeSetextUnderline,
4781  resolveTo: resolveToSetextUnderline
4782};
4783function resolveToSetextUnderline(events, context) {
4784  var index = events.length;
4785  var content;
4786  var text;
4787  var definition;
4788  var heading;
4789  while (index--) {
4790    if (events[index][0] === "enter") {
4791      if (events[index][1].type === "content") {
4792        content = index;
4793        break;
4794      }
4795      if (events[index][1].type === "paragraph") {
4796        text = index;
4797      }
4798    } else {
4799      if (events[index][1].type === "content") {
4800        events.splice(index, 1);
4801      }
4802      if (!definition && events[index][1].type === "definition") {
4803        definition = index;
4804      }
4805    }
4806  }
4807  heading = {
4808    type: "setextHeading",
4809    start: shallow(events[text][1].start),
4810    end: shallow(events[events.length - 1][1].end)
4811  };
4812  events[text][1].type = "setextHeadingText";
4813  if (definition) {
4814    events.splice(text, 0, ["enter", heading, context]);
4815    events.splice(definition + 1, 0, ["exit", events[content][1], context]);
4816    events[content][1].end = shallow(events[definition][1].end);
4817  } else {
4818    events[content][1] = heading;
4819  }
4820  events.push(["exit", heading, context]);
4821  return events;
4822}
4823function tokenizeSetextUnderline(effects, ok, nok) {
4824  var self = this;
4825  var index = self.events.length;
4826  var marker;
4827  var paragraph;
4828  while (index--) {
4829    if (self.events[index][1].type !== "lineEnding" && self.events[index][1].type !== "linePrefix" && self.events[index][1].type !== "content") {
4830      paragraph = self.events[index][1].type === "paragraph";
4831      break;
4832    }
4833  }
4834  return start;
4835  function start(code) {
4836    if (!self.lazy && (self.interrupt || paragraph)) {
4837      effects.enter("setextHeadingLine");
4838      effects.enter("setextHeadingLineSequence");
4839      marker = code;
4840      return closingSequence(code);
4841    }
4842    return nok(code);
4843  }
4844  function closingSequence(code) {
4845    if (code === marker) {
4846      effects.consume(code);
4847      return closingSequence;
4848    }
4849    effects.exit("setextHeadingLineSequence");
4850    return factorySpace(effects, closingSequenceEnd, "lineSuffix")(code);
4851  }
4852  function closingSequenceEnd(code) {
4853    if (code === null || markdownLineEnding(code)) {
4854      effects.exit("setextHeadingLine");
4855      return ok(code);
4856    }
4857    return nok(code);
4858  }
4859}
4860module.exports = setextUnderline;
4861
4862
4863/***/ },
4864
4865/***/ 75911
4866(module, __unused_webpack_exports, __webpack_require__) {
4867
4868"use strict";
4869
4870var markdownLineEnding = __webpack_require__(63336);
4871var markdownSpace = __webpack_require__(24248);
4872var factorySpace = __webpack_require__(42145);
4873var thematicBreak = {
4874  name: "thematicBreak",
4875  tokenize: tokenizeThematicBreak
4876};
4877function tokenizeThematicBreak(effects, ok, nok) {
4878  var size = 0;
4879  var marker;
4880  return start;
4881  function start(code) {
4882    effects.enter("thematicBreak");
4883    marker = code;
4884    return atBreak(code);
4885  }
4886  function atBreak(code) {
4887    if (code === marker) {
4888      effects.enter("thematicBreakSequence");
4889      return sequence(code);
4890    }
4891    if (markdownSpace(code)) {
4892      return factorySpace(effects, atBreak, "whitespace")(code);
4893    }
4894    if (size < 3 || code !== null && !markdownLineEnding(code)) {
4895      return nok(code);
4896    }
4897    effects.exit("thematicBreak");
4898    return ok(code);
4899  }
4900  function sequence(code) {
4901    if (code === marker) {
4902      effects.consume(code);
4903      size++;
4904      return sequence;
4905    }
4906    effects.exit("thematicBreakSequence");
4907    return atBreak(code);
4908  }
4909}
4910module.exports = thematicBreak;
4911
4912
4913/***/ },
4914
4915/***/ 90638
4916(module, __unused_webpack_exports, __webpack_require__) {
4917
4918"use strict";
4919
4920var chunkedSplice = __webpack_require__(50638);
4921function chunkedPush(list, items) {
4922  if (list.length) {
4923    chunkedSplice(list, list.length, 0, items);
4924    return list;
4925  }
4926  return items;
4927}
4928module.exports = chunkedPush;
4929
4930
4931/***/ },
4932
4933/***/ 50638
4934(module, __unused_webpack_exports, __webpack_require__) {
4935
4936"use strict";
4937
4938var splice = __webpack_require__(42173);
4939function chunkedSplice(list, start, remove, items) {
4940  var end = list.length;
4941  var chunkStart = 0;
4942  var parameters;
4943  if (start < 0) {
4944    start = -start > end ? 0 : end + start;
4945  } else {
4946    start = start > end ? end : start;
4947  }
4948  remove = remove > 0 ? remove : 0;
4949  if (items.length < 1e4) {
4950    parameters = Array.from(items);
4951    parameters.unshift(start, remove);
4952    splice.apply(list, parameters);
4953  } else {
4954    if (remove) splice.apply(list, [start, remove]);
4955    while (chunkStart < items.length) {
4956      parameters = items.slice(chunkStart, chunkStart + 1e4);
4957      parameters.unshift(start, 0);
4958      splice.apply(list, parameters);
4959      chunkStart += 1e4;
4960      start += 1e4;
4961    }
4962  }
4963}
4964module.exports = chunkedSplice;
4965
4966
4967/***/ },
4968
4969/***/ 13598
4970(module, __unused_webpack_exports, __webpack_require__) {
4971
4972"use strict";
4973
4974var markdownLineEndingOrSpace = __webpack_require__(2575);
4975var unicodePunctuation = __webpack_require__(62082);
4976var unicodeWhitespace = __webpack_require__(92813);
4977function classifyCharacter(code) {
4978  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
4979    return 1;
4980  }
4981  if (unicodePunctuation(code)) {
4982    return 2;
4983  }
4984}
4985module.exports = classifyCharacter;
4986
4987
4988/***/ },
4989
4990/***/ 67511
4991(module, __unused_webpack_exports, __webpack_require__) {
4992
4993"use strict";
4994
4995var hasOwnProperty = __webpack_require__(78736);
4996var chunkedSplice = __webpack_require__(50638);
4997var miniflat = __webpack_require__(56489);
4998function combineExtensions(extensions) {
4999  var all = {};
5000  var index = -1;
5001  while (++index < extensions.length) {
5002    extension(all, extensions[index]);
5003  }
5004  return all;
5005}
5006function extension(all, extension2) {
5007  var hook;
5008  var left;
5009  var right;
5010  var code;
5011  for (hook in extension2) {
5012    left = hasOwnProperty.call(all, hook) ? all[hook] : all[hook] = {};
5013    right = extension2[hook];
5014    for (code in right) {
5015      left[code] = constructs(
5016        miniflat(right[code]),
5017        hasOwnProperty.call(left, code) ? left[code] : []
5018      );
5019    }
5020  }
5021}
5022function constructs(list, existing) {
5023  var index = -1;
5024  var before = [];
5025  while (++index < list.length) {
5026    ;
5027    (list[index].add === "after" ? existing : before).push(list[index]);
5028  }
5029  chunkedSplice(existing, 0, 0, before);
5030  return existing;
5031}
5032module.exports = combineExtensions;
5033
5034
5035/***/ },
5036
5037/***/ 99573
5038(module, __unused_webpack_exports, __webpack_require__) {
5039
5040"use strict";
5041
5042var assign = __webpack_require__(44552);
5043var markdownLineEnding = __webpack_require__(63336);
5044var chunkedPush = __webpack_require__(90638);
5045var chunkedSplice = __webpack_require__(50638);
5046var miniflat = __webpack_require__(56489);
5047var resolveAll = __webpack_require__(33399);
5048var serializeChunks = __webpack_require__(1074);
5049var shallow = __webpack_require__(34645);
5050var sliceChunks = __webpack_require__(68362);
5051function createTokenizer(parser, initialize, from) {
5052  var point = from ? shallow(from) : {
5053    line: 1,
5054    column: 1,
5055    offset: 0
5056  };
5057  var columnStart = {};
5058  var resolveAllConstructs = [];
5059  var chunks = [];
5060  var stack = [];
5061  var effects = {
5062    consume,
5063    enter,
5064    exit,
5065    attempt: constructFactory(onsuccessfulconstruct),
5066    check: constructFactory(onsuccessfulcheck),
5067    interrupt: constructFactory(onsuccessfulcheck, {
5068      interrupt: true
5069    }),
5070    lazy: constructFactory(onsuccessfulcheck, {
5071      lazy: true
5072    })
5073  };
5074  var context = {
5075    previous: null,
5076    events: [],
5077    parser,
5078    sliceStream,
5079    sliceSerialize,
5080    now,
5081    defineSkip: skip,
5082    write
5083  };
5084  var state = initialize.tokenize.call(context, effects);
5085  if (initialize.resolveAll) {
5086    resolveAllConstructs.push(initialize);
5087  }
5088  point._index = 0;
5089  point._bufferIndex = -1;
5090  return context;
5091  function write(slice) {
5092    chunks = chunkedPush(chunks, slice);
5093    main();
5094    if (chunks[chunks.length - 1] !== null) {
5095      return [];
5096    }
5097    addResult(initialize, 0);
5098    context.events = resolveAll(resolveAllConstructs, context.events, context);
5099    return context.events;
5100  }
5101  function sliceSerialize(token) {
5102    return serializeChunks(sliceStream(token));
5103  }
5104  function sliceStream(token) {
5105    return sliceChunks(chunks, token);
5106  }
5107  function now() {
5108    return shallow(point);
5109  }
5110  function skip(value) {
5111    columnStart[value.line] = value.column;
5112    accountForPotentialSkip();
5113  }
5114  function main() {
5115    var chunkIndex;
5116    var chunk;
5117    while (point._index < chunks.length) {
5118      chunk = chunks[point._index];
5119      if (typeof chunk === "string") {
5120        chunkIndex = point._index;
5121        if (point._bufferIndex < 0) {
5122          point._bufferIndex = 0;
5123        }
5124        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {
5125          go(chunk.charCodeAt(point._bufferIndex));
5126        }
5127      } else {
5128        go(chunk);
5129      }
5130    }
5131  }
5132  function go(code) {
5133    state = state(code);
5134  }
5135  function consume(code) {
5136    if (markdownLineEnding(code)) {
5137      point.line++;
5138      point.column = 1;
5139      point.offset += code === -3 ? 2 : 1;
5140      accountForPotentialSkip();
5141    } else if (code !== -1) {
5142      point.column++;
5143      point.offset++;
5144    }
5145    if (point._bufferIndex < 0) {
5146      point._index++;
5147    } else {
5148      point._bufferIndex++;
5149      if (point._bufferIndex === chunks[point._index].length) {
5150        point._bufferIndex = -1;
5151        point._index++;
5152      }
5153    }
5154    context.previous = code;
5155  }
5156  function enter(type, fields) {
5157    var token = fields || {};
5158    token.type = type;
5159    token.start = now();
5160    context.events.push(["enter", token, context]);
5161    stack.push(token);
5162    return token;
5163  }
5164  function exit(type) {
5165    var token = stack.pop();
5166    token.end = now();
5167    context.events.push(["exit", token, context]);
5168    return token;
5169  }
5170  function onsuccessfulconstruct(construct, info) {
5171    addResult(construct, info.from);
5172  }
5173  function onsuccessfulcheck(construct, info) {
5174    info.restore();
5175  }
5176  function constructFactory(onreturn, fields) {
5177    return hook;
5178    function hook(constructs, returnState, bogusState) {
5179      var listOfConstructs;
5180      var constructIndex;
5181      var currentConstruct;
5182      var info;
5183      return constructs.tokenize || "length" in constructs ? handleListOfConstructs(miniflat(constructs)) : handleMapOfConstructs;
5184      function handleMapOfConstructs(code) {
5185        if (code in constructs || null in constructs) {
5186          return handleListOfConstructs(
5187            constructs.null ? (
5188              /* c8 ignore next */
5189              miniflat(constructs[code]).concat(miniflat(constructs.null))
5190            ) : constructs[code]
5191          )(code);
5192        }
5193        return bogusState(code);
5194      }
5195      function handleListOfConstructs(list) {
5196        listOfConstructs = list;
5197        constructIndex = 0;
5198        return handleConstruct(list[constructIndex]);
5199      }
5200      function handleConstruct(construct) {
5201        return start;
5202        function start(code) {
5203          info = store();
5204          currentConstruct = construct;
5205          if (!construct.partial) {
5206            context.currentConstruct = construct;
5207          }
5208          if (construct.name && context.parser.constructs.disable.null.indexOf(construct.name) > -1) {
5209            return nok();
5210          }
5211          return construct.tokenize.call(
5212            fields ? assign({}, context, fields) : context,
5213            effects,
5214            ok,
5215            nok
5216          )(code);
5217        }
5218      }
5219      function ok(code) {
5220        onreturn(currentConstruct, info);
5221        return returnState;
5222      }
5223      function nok(code) {
5224        info.restore();
5225        if (++constructIndex < listOfConstructs.length) {
5226          return handleConstruct(listOfConstructs[constructIndex]);
5227        }
5228        return bogusState;
5229      }
5230    }
5231  }
5232  function addResult(construct, from2) {
5233    if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {
5234      resolveAllConstructs.push(construct);
5235    }
5236    if (construct.resolve) {
5237      chunkedSplice(
5238        context.events,
5239        from2,
5240        context.events.length - from2,
5241        construct.resolve(context.events.slice(from2), context)
5242      );
5243    }
5244    if (construct.resolveTo) {
5245      context.events = construct.resolveTo(context.events, context);
5246    }
5247  }
5248  function store() {
5249    var startPoint = now();
5250    var startPrevious = context.previous;
5251    var startCurrentConstruct = context.currentConstruct;
5252    var startEventsIndex = context.events.length;
5253    var startStack = Array.from(stack);
5254    return {
5255      restore,
5256      from: startEventsIndex
5257    };
5258    function restore() {
5259      point = startPoint;
5260      context.previous = startPrevious;
5261      context.currentConstruct = startCurrentConstruct;
5262      context.events.length = startEventsIndex;
5263      stack = startStack;
5264      accountForPotentialSkip();
5265    }
5266  }
5267  function accountForPotentialSkip() {
5268    if (point.line in columnStart && point.column < 2) {
5269      point.column = columnStart[point.line];
5270      point.offset += columnStart[point.line] - 1;
5271    }
5272  }
5273}
5274module.exports = createTokenizer;
5275
5276
5277/***/ },
5278
5279/***/ 56489
5280(module) {
5281
5282"use strict";
5283
5284function miniflat(value) {
5285  return value === null || value === void 0 ? [] : "length" in value ? value : [value];
5286}
5287module.exports = miniflat;
5288
5289
5290/***/ },
5291
5292/***/ 99163
5293(module) {
5294
5295"use strict";
5296
5297function movePoint(point, offset) {
5298  point.column += offset;
5299  point.offset += offset;
5300  point._bufferIndex += offset;
5301  return point;
5302}
5303module.exports = movePoint;
5304
5305
5306/***/ },
5307
5308/***/ 17904
5309(module) {
5310
5311"use strict";
5312
5313function normalizeIdentifier(value) {
5314  return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
5315}
5316module.exports = normalizeIdentifier;
5317
5318
5319/***/ },
5320
5321/***/ 71795
5322(module, __unused_webpack_exports, __webpack_require__) {
5323
5324"use strict";
5325
5326var sizeChunks = __webpack_require__(87175);
5327function prefixSize(events, type) {
5328  var tail = events[events.length - 1];
5329  if (!tail || tail[1].type !== type) return 0;
5330  return sizeChunks(tail[2].sliceStream(tail[1]));
5331}
5332module.exports = prefixSize;
5333
5334
5335/***/ },
5336
5337/***/ 70811
5338(module, __unused_webpack_exports, __webpack_require__) {
5339
5340"use strict";
5341
5342var fromCharCode = __webpack_require__(86778);
5343function regexCheck(regex) {
5344  return check;
5345  function check(code) {
5346    return regex.test(fromCharCode(code));
5347  }
5348}
5349module.exports = regexCheck;
5350
5351
5352/***/ },
5353
5354/***/ 33399
5355(module) {
5356
5357"use strict";
5358
5359function resolveAll(constructs, events, context) {
5360  var called = [];
5361  var index = -1;
5362  var resolve;
5363  while (++index < constructs.length) {
5364    resolve = constructs[index].resolveAll;
5365    if (resolve && called.indexOf(resolve) < 0) {
5366      events = resolve(events, context);
5367      called.push(resolve);
5368    }
5369  }
5370  return events;
5371}
5372module.exports = resolveAll;
5373
5374
5375/***/ },
5376
5377/***/ 6133
5378(module, __unused_webpack_exports, __webpack_require__) {
5379
5380"use strict";
5381
5382var fromCharCode = __webpack_require__(86778);
5383function safeFromInt(value, base) {
5384  var code = parseInt(value, base);
5385  if (
5386    // C0 except for HT, LF, FF, CR, space
5387    code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of the basic block and C1 controls.
5388    code > 126 && code < 160 || // Lone high surrogates and low surrogates.
5389    code > 55295 && code < 57344 || // Noncharacters.
5390    code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range
5391    code > 1114111
5392  ) {
5393    return "\uFFFD";
5394  }
5395  return fromCharCode(code);
5396}
5397module.exports = safeFromInt;
5398
5399
5400/***/ },
5401
5402/***/ 1074
5403(module, __unused_webpack_exports, __webpack_require__) {
5404
5405"use strict";
5406
5407var fromCharCode = __webpack_require__(86778);
5408function serializeChunks(chunks) {
5409  var index = -1;
5410  var result = [];
5411  var chunk;
5412  var value;
5413  var atTab;
5414  while (++index < chunks.length) {
5415    chunk = chunks[index];
5416    if (typeof chunk === "string") {
5417      value = chunk;
5418    } else if (chunk === -5) {
5419      value = "\r";
5420    } else if (chunk === -4) {
5421      value = "\n";
5422    } else if (chunk === -3) {
5423      value = "\r\n";
5424    } else if (chunk === -2) {
5425      value = "	";
5426    } else if (chunk === -1) {
5427      if (atTab) continue;
5428      value = " ";
5429    } else {
5430      value = fromCharCode(chunk);
5431    }
5432    atTab = chunk === -2;
5433    result.push(value);
5434  }
5435  return result.join("");
5436}
5437module.exports = serializeChunks;
5438
5439
5440/***/ },
5441
5442/***/ 34645
5443(module, __unused_webpack_exports, __webpack_require__) {
5444
5445"use strict";
5446
5447var assign = __webpack_require__(44552);
5448function shallow(object) {
5449  return assign({}, object);
5450}
5451module.exports = shallow;
5452
5453
5454/***/ },
5455
5456/***/ 87175
5457(module) {
5458
5459"use strict";
5460
5461function sizeChunks(chunks) {
5462  var index = -1;
5463  var size = 0;
5464  while (++index < chunks.length) {
5465    size += typeof chunks[index] === "string" ? chunks[index].length : 1;
5466  }
5467  return size;
5468}
5469module.exports = sizeChunks;
5470
5471
5472/***/ },
5473
5474/***/ 68362
5475(module) {
5476
5477"use strict";
5478
5479function sliceChunks(chunks, token) {
5480  var startIndex = token.start._index;
5481  var startBufferIndex = token.start._bufferIndex;
5482  var endIndex = token.end._index;
5483  var endBufferIndex = token.end._bufferIndex;
5484  var view;
5485  if (startIndex === endIndex) {
5486    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
5487  } else {
5488    view = chunks.slice(startIndex, endIndex);
5489    if (startBufferIndex > -1) {
5490      view[0] = view[0].slice(startBufferIndex);
5491    }
5492    if (endBufferIndex > 0) {
5493      view.push(chunks[endIndex].slice(0, endBufferIndex));
5494    }
5495  }
5496  return view;
5497}
5498module.exports = sliceChunks;
5499
5500
5501/***/ },
5502
5503/***/ 26306
5504(module, __unused_webpack_exports, __webpack_require__) {
5505
5506"use strict";
5507
5508var assign = __webpack_require__(44552);
5509var chunkedSplice = __webpack_require__(50638);
5510var shallow = __webpack_require__(34645);
5511function subtokenize(events) {
5512  var jumps = {};
5513  var index = -1;
5514  var event;
5515  var lineIndex;
5516  var otherIndex;
5517  var otherEvent;
5518  var parameters;
5519  var subevents;
5520  var more;
5521  while (++index < events.length) {
5522    while (index in jumps) {
5523      index = jumps[index];
5524    }
5525    event = events[index];
5526    if (index && event[1].type === "chunkFlow" && events[index - 1][1].type === "listItemPrefix") {
5527      subevents = event[1]._tokenizer.events;
5528      otherIndex = 0;
5529      if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") {
5530        otherIndex += 2;
5531      }
5532      if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") {
5533        while (++otherIndex < subevents.length) {
5534          if (subevents[otherIndex][1].type === "content") {
5535            break;
5536          }
5537          if (subevents[otherIndex][1].type === "chunkText") {
5538            subevents[otherIndex][1].isInFirstContentOfListItem = true;
5539            otherIndex++;
5540          }
5541        }
5542      }
5543    }
5544    if (event[0] === "enter") {
5545      if (event[1].contentType) {
5546        assign(jumps, subcontent(events, index));
5547        index = jumps[index];
5548        more = true;
5549      }
5550    } else if (event[1]._container || event[1]._movePreviousLineEndings) {
5551      otherIndex = index;
5552      lineIndex = void 0;
5553      while (otherIndex--) {
5554        otherEvent = events[otherIndex];
5555        if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") {
5556          if (otherEvent[0] === "enter") {
5557            if (lineIndex) {
5558              events[lineIndex][1].type = "lineEndingBlank";
5559            }
5560            otherEvent[1].type = "lineEnding";
5561            lineIndex = otherIndex;
5562          }
5563        } else {
5564          break;
5565        }
5566      }
5567      if (lineIndex) {
5568        event[1].end = shallow(events[lineIndex][1].start);
5569        parameters = events.slice(lineIndex, index);
5570        parameters.unshift(event);
5571        chunkedSplice(events, lineIndex, index - lineIndex + 1, parameters);
5572      }
5573    }
5574  }
5575  return !more;
5576}
5577function subcontent(events, eventIndex) {
5578  var token = events[eventIndex][1];
5579  var context = events[eventIndex][2];
5580  var startPosition = eventIndex - 1;
5581  var startPositions = [];
5582  var tokenizer = token._tokenizer || context.parser[token.contentType](token.start);
5583  var childEvents = tokenizer.events;
5584  var jumps = [];
5585  var gaps = {};
5586  var stream;
5587  var previous;
5588  var index;
5589  var entered;
5590  var end;
5591  var adjust;
5592  while (token) {
5593    while (events[++startPosition][1] !== token) {
5594    }
5595    startPositions.push(startPosition);
5596    if (!token._tokenizer) {
5597      stream = context.sliceStream(token);
5598      if (!token.next) {
5599        stream.push(null);
5600      }
5601      if (previous) {
5602        tokenizer.defineSkip(token.start);
5603      }
5604      if (token.isInFirstContentOfListItem) {
5605        tokenizer._gfmTasklistFirstContentOfListItem = true;
5606      }
5607      tokenizer.write(stream);
5608      if (token.isInFirstContentOfListItem) {
5609        tokenizer._gfmTasklistFirstContentOfListItem = void 0;
5610      }
5611    }
5612    previous = token;
5613    token = token.next;
5614  }
5615  token = previous;
5616  index = childEvents.length;
5617  while (index--) {
5618    if (childEvents[index][0] === "enter") {
5619      entered = true;
5620    } else if (
5621      // Find a void token that includes a break.
5622      entered && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line
5623    ) {
5624      add(childEvents.slice(index + 1, end));
5625      token._tokenizer = token.next = void 0;
5626      token = token.previous;
5627      end = index + 1;
5628    }
5629  }
5630  tokenizer.events = token._tokenizer = token.next = void 0;
5631  add(childEvents.slice(0, end));
5632  index = -1;
5633  adjust = 0;
5634  while (++index < jumps.length) {
5635    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
5636    adjust += jumps[index][1] - jumps[index][0] - 1;
5637  }
5638  return gaps;
5639  function add(slice) {
5640    var start = startPositions.pop();
5641    jumps.unshift([start, start + slice.length - 1]);
5642    chunkedSplice(events, start, 2, slice);
5643  }
5644}
5645module.exports = subtokenize;
5646
5647
5648/***/ },
5649
5650/***/ 72859
5651(module) {
5652
5653"use strict";
5654
5655var el;
5656var semicolon = 59;
5657module.exports = decodeEntity;
5658function decodeEntity(characters) {
5659  var entity = "&" + characters + ";";
5660  var char;
5661  el = el || document.createElement("i");