1256 |
1257 | if (options.simplifiedAutoLink) {
1258 | text = text.replace(simpleURLRegex, replaceLink);
1259 | text = text.replace(simpleMailRegex, replaceMail);
1260 | }
1261 |
1262 | function replaceLink(wm, link) {
1263 | var lnkTxt = link;
1264 | if (/^www\./i.test(link)) {
1265 | link = link.replace(/^www\./i, 'http://www.');
1266 | }
1267 | return '' + lnkTxt + '';
1268 | }
1269 |
1270 | function replaceMail(wholeMatch, m1) {
1271 | var unescapedStr = showdown.subParser('unescapeSpecialChars')(m1);
1272 | return showdown.subParser('encodeEmailAddress')(unescapedStr);
1273 | }
1274 |
1275 | text = globals.converter._dispatch('autoLinks.after', text, options, globals);
1276 |
1277 | return text;
1278 | });
1279 |
1280 | /**
1281 | * These are all the transformations that form block-level
1282 | * tags like paragraphs, headers, and list items.
1283 | */
1284 | showdown.subParser('blockGamut', function (text, options, globals) {
1285 | 'use strict';
1286 |
1287 | text = globals.converter._dispatch('blockGamut.before', text, options, globals);
1288 |
1289 | // we parse blockquotes first so that we can have headings and hrs
1290 | // inside blockquotes
1291 | text = showdown.subParser('blockQuotes')(text, options, globals);
1292 | text = showdown.subParser('headers')(text, options, globals);
1293 |
1294 | // Do Horizontal Rules:
1295 | var key = showdown.subParser('hashBlock')('
', options, globals);
1296 | text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm, key);
1297 | text = text.replace(/^[ ]{0,2}([ ]?\-[ ]?){3,}[ \t]*$/gm, key);
1298 | text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm, key);
1299 |
1300 | text = showdown.subParser('lists')(text, options, globals);
1301 | text = showdown.subParser('codeBlocks')(text, options, globals);
1302 | text = showdown.subParser('tables')(text, options, globals);
1303 |
1304 | // We already ran _HashHTMLBlocks() before, in Markdown(), but that
1305 | // was to escape raw HTML in the original Markdown source. This time,
1306 | // we're escaping the markup we've just created, so that we don't wrap
1307 | // tags around block-level tags.
1308 | text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
1309 | text = showdown.subParser('paragraphs')(text, options, globals);
1310 |
1311 | text = globals.converter._dispatch('blockGamut.after', text, options, globals);
1312 |
1313 | return text;
1314 | });
1315 |
1316 | showdown.subParser('blockQuotes', function (text, options, globals) {
1317 | 'use strict';
1318 |
1319 | text = globals.converter._dispatch('blockQuotes.before', text, options, globals);
1320 | /*
1321 | text = text.replace(/
1322 | ( // Wrap whole match in $1
1323 | (
1324 | ^[ \t]*>[ \t]? // '>' at the start of a line
1325 | .+\n // rest of the first line
1326 | (.+\n)* // subsequent consecutive lines
1327 | \n* // blanks
1328 | )+
1329 | )
1330 | /gm, function(){...});
1331 | */
1332 |
1333 | text = text.replace(/((^[ \t]{0,3}>[ \t]?.+\n(.+\n)*\n*)+)/gm, function (wholeMatch, m1) {
1334 | var bq = m1;
1335 |
1336 | // attacklab: hack around Konqueror 3.5.4 bug:
1337 | // "----------bug".replace(/^-/g,"") == "bug"
1338 | bq = bq.replace(/^[ \t]*>[ \t]?/gm, '~0'); // trim one level of quoting
1339 |
1340 | // attacklab: clean up hack
1341 | bq = bq.replace(/~0/g, '');
1342 |
1343 | bq = bq.replace(/^[ \t]+$/gm, ''); // trim whitespace-only lines
1344 | bq = showdown.subParser('githubCodeBlocks')(bq, options, globals);
1345 | bq = showdown.subParser('blockGamut')(bq, options, globals); // recurse
1346 |
1347 | bq = bq.replace(/(^|\n)/g, '$1 ');
1348 | // These leading spaces screw with
content, so we need to fix that:
1349 | bq = bq.replace(/(\s*[^\r]+?<\/pre>)/gm, function (wholeMatch, m1) {
1350 | var pre = m1;
1351 | // attacklab: hack around Konqueror 3.5.4 bug:
1352 | pre = pre.replace(/^ /mg, '~0');
1353 | pre = pre.replace(/~0/g, '');
1354 | return pre;
1355 | });
1356 |
1357 | return showdown.subParser('hashBlock')('\n' + bq + '\n
', options, globals);
1358 | });
1359 |
1360 | text = globals.converter._dispatch('blockQuotes.after', text, options, globals);
1361 | return text;
1362 | });
1363 |
1364 | /**
1365 | * Process Markdown `` blocks.
1366 | */
1367 | showdown.subParser('codeBlocks', function (text, options, globals) {
1368 | 'use strict';
1369 |
1370 | text = globals.converter._dispatch('codeBlocks.before', text, options, globals);
1371 | /*
1372 | text = text.replace(text,
1373 | /(?:\n\n|^)
1374 | ( // $1 = the code block -- one or more lines, starting with a space/tab
1375 | (?:
1376 | (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
1377 | .*\n+
1378 | )+
1379 | )
1380 | (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
1381 | /g,function(){...});
1382 | */
1383 |
1384 | // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
1385 | text += '~0';
1386 |
1387 | var pattern = /(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g;
1388 | text = text.replace(pattern, function (wholeMatch, m1, m2) {
1389 | var codeblock = m1,
1390 | nextChar = m2,
1391 | end = '\n';
1392 |
1393 | codeblock = showdown.subParser('outdent')(codeblock);
1394 | codeblock = showdown.subParser('encodeCode')(codeblock);
1395 | codeblock = showdown.subParser('detab')(codeblock);
1396 | codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
1397 | codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing newlines
1398 |
1399 | if (options.omitExtraWLInCodeBlocks) {
1400 | end = '';
1401 | }
1402 |
1403 | codeblock = '' + codeblock + end + '
';
1404 |
1405 | return showdown.subParser('hashBlock')(codeblock, options, globals) + nextChar;
1406 | });
1407 |
1408 | // attacklab: strip sentinel
1409 | text = text.replace(/~0/, '');
1410 |
1411 | text = globals.converter._dispatch('codeBlocks.after', text, options, globals);
1412 | return text;
1413 | });
1414 |
1415 | /**
1416 | *
1417 | * * Backtick quotes are used for Just type foo `bar` baz at the prompt.
1427 | *
1428 | * There's no arbitrary limit to the number of backticks you
1429 | * can use as delimters. If you need three consecutive backticks
1430 | * in your code, use four for delimiters, etc.
1431 | *
1432 | * * You can use spaces to get literal backticks at the edges:
1433 | *
1434 | * ... type `` `bar` `` ...
1435 | *
1436 | * Turns to:
1437 | *
1438 | * ... type `bar` ...
1439 | */
1440 | showdown.subParser('codeSpans', function (text, options, globals) {
1441 | 'use strict';
1442 |
1443 | text = globals.converter._dispatch('codeSpans.before', text, options, globals);
1444 |
1445 | /*
1446 | text = text.replace(/
1447 | (^|[^\\]) // Character before opening ` can't be a backslash
1448 | (`+) // $2 = Opening run of `
1449 | ( // $3 = The code block
1450 | [^\r]*?
1451 | [^`] // attacklab: work around lack of lookbehind
1452 | )
1453 | \2 // Matching closer
1454 | (?!`)
1455 | /gm, function(){...});
1456 | */
1457 |
1458 | if (typeof(text) === 'undefined') {
1459 | text = '';
1460 | }
1461 | text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
1462 | function (wholeMatch, m1, m2, m3) {
1463 | var c = m3;
1464 | c = c.replace(/^([ \t]*)/g, ''); // leading whitespace
1465 | c = c.replace(/[ \t]*$/g, ''); // trailing whitespace
1466 | c = showdown.subParser('encodeCode')(c);
1467 | return m1 + '' + c + '';
1468 | }
1469 | );
1470 |
1471 | text = globals.converter._dispatch('codeSpans.after', text, options, globals);
1472 | return text;
1473 | });
1474 |
1475 | /**
1476 | * Convert all tabs to spaces
1477 | */
1478 | showdown.subParser('detab', function (text) {
1479 | 'use strict';
1480 |
1481 | // expand first n-1 tabs
1482 | text = text.replace(/\t(?=\t)/g, ' '); // g_tab_width
1483 |
1484 | // replace the nth with two sentinels
1485 | text = text.replace(/\t/g, '~A~B');
1486 |
1487 | // use the sentinel to anchor our regex so it doesn't explode
1488 | text = text.replace(/~B(.+?)~A/g, function (wholeMatch, m1) {
1489 | var leadingText = m1,
1490 | numSpaces = 4 - leadingText.length % 4; // g_tab_width
1491 |
1492 | // there *must* be a better way to do this:
1493 | for (var i = 0; i < numSpaces; i++) {
1494 | leadingText += ' ';
1495 | }
1496 |
1497 | return leadingText;
1498 | });
1499 |
1500 | // clean up sentinels
1501 | text = text.replace(/~A/g, ' '); // g_tab_width
1502 | text = text.replace(/~B/g, '');
1503 |
1504 | return text;
1505 |
1506 | });
1507 |
1508 | /**
1509 | * Smart processing for ampersands and angle brackets that need to be encoded.
1510 | */
1511 | showdown.subParser('encodeAmpsAndAngles', function (text) {
1512 | 'use strict';
1513 | // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
1514 | // http://bumppo.net/projects/amputator/
1515 | text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g, '&');
1516 |
1517 | // Encode naked <'s
1518 | text = text.replace(/<(?![a-z\/?\$!])/gi, '<');
1519 |
1520 | return text;
1521 | });
1522 |
1523 | /**
1524 | * Returns the string, with after processing the following backslash escape sequences.
1525 | *
1526 | * attacklab: The polite way to do this is with the new escapeCharacters() function:
1527 | *
1528 | * text = escapeCharacters(text,"\\",true);
1529 | * text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
1530 | *
1531 | * ...but we're sidestepping its use of the (slow) RegExp constructor
1532 | * as an optimization for Firefox. This function gets called a LOT.
1533 | */
1534 | showdown.subParser('encodeBackslashEscapes', function (text) {
1535 | 'use strict';
1536 | text = text.replace(/\\(\\)/g, showdown.helper.escapeCharactersCallback);
1537 | text = text.replace(/\\([`*_{}\[\]()>#+-.!])/g, showdown.helper.escapeCharactersCallback);
1538 | return text;
1539 | });
1540 |
1541 | /**
1542 | * Encode/escape certain characters inside Markdown code runs.
1543 | * The point is that in code, these characters are literals,
1544 | * and lose their special Markdown meanings.
1545 | */
1546 | showdown.subParser('encodeCode', function (text) {
1547 | 'use strict';
1548 |
1549 | // Encode all ampersands; HTML entities are not
1550 | // entities within a Markdown code span.
1551 | text = text.replace(/&/g, '&');
1552 |
1553 | // Do the angle bracket song and dance:
1554 | text = text.replace(//g, '>');
1556 |
1557 | // Now, escape characters that are magic in Markdown:
1558 | text = showdown.helper.escapeCharacters(text, '*_{}[]\\', false);
1559 |
1560 | // jj the line above breaks this:
1561 | //---
1562 | //* Item
1563 | // 1. Subitem
1564 | // special char: *
1565 | // ---
1566 |
1567 | return text;
1568 | });
1569 |
1570 | /**
1571 | * Input: an email address, e.g. "foo@example.com"
1572 | *
1573 | * Output: the email address as a mailto link, with each character
1574 | * of the address encoded as either a decimal or hex entity, in
1575 | * the hopes of foiling most address harvesting spam bots. E.g.:
1576 | *
1577 | * foo
1579 | * @example.com
1580 | *
1581 | * Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
1582 | * mailing list:
1583 | *
1584 | */
1585 | showdown.subParser('encodeEmailAddress', function (addr) {
1586 | 'use strict';
1587 |
1588 | var encode = [
1589 | function (ch) {
1590 | return '&#' + ch.charCodeAt(0) + ';';
1591 | },
1592 | function (ch) {
1593 | return '&#x' + ch.charCodeAt(0).toString(16) + ';';
1594 | },
1595 | function (ch) {
1596 | return ch;
1597 | }
1598 | ];
1599 |
1600 | addr = 'mailto:' + addr;
1601 |
1602 | addr = addr.replace(/./g, function (ch) {
1603 | if (ch === '@') {
1604 | // this *must* be encoded. I insist.
1605 | ch = encode[Math.floor(Math.random() * 2)](ch);
1606 | } else if (ch !== ':') {
1607 | // leave ':' alone (to spot mailto: later)
1608 | var r = Math.random();
1609 | // roughly 10% raw, 45% hex, 45% dec
1610 | ch = (
1611 | r > 0.9 ? encode[2](ch) : r > 0.45 ? encode[1](ch) : encode[0](ch)
1612 | );
1613 | }
1614 | return ch;
1615 | });
1616 |
1617 | addr = '' + addr + '';
1618 | addr = addr.replace(/">.+:/g, '">'); // strip the mailto: from the visible part
1619 |
1620 | return addr;
1621 | });
1622 |
1623 | /**
1624 | * Within tags -- meaning between < and > -- encode [\ ` * _] so they
1625 | * don't conflict with their use in Markdown for code, italics and strong.
1626 | */
1627 | showdown.subParser('escapeSpecialCharsWithinTagAttributes', function (text) {
1628 | 'use strict';
1629 |
1630 | // Build a regex to find HTML tags and comments. See Friedl's
1631 | // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
1632 | var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|)/gi;
1633 |
1634 | text = text.replace(regex, function (wholeMatch) {
1635 | var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g, '$1`');
1636 | tag = showdown.helper.escapeCharacters(tag, '\\`*_', false);
1637 | return tag;
1638 | });
1639 |
1640 | return text;
1641 | });
1642 |
1643 | /**
1644 | * Handle github codeblocks prior to running HashHTML so that
1645 | * HTML contained within the codeblock gets escaped properly
1646 | * Example:
1647 | * ```ruby
1648 | * def hello_world(x)
1649 | * puts "Hello, #{x}"
1650 | * end
1651 | * ```
1652 | */
1653 | showdown.subParser('githubCodeBlocks', function (text, options, globals) {
1654 | 'use strict';
1655 |
1656 | // early exit if option is not enabled
1657 | if (!options.ghCodeBlocks) {
1658 | return text;
1659 | }
1660 |
1661 | text = globals.converter._dispatch('githubCodeBlocks.before', text, options, globals);
1662 |
1663 | text += '~0';
1664 |
1665 | text = text.replace(/(?:^|\n)```(.*)\n([\s\S]*?)\n```/g, function (wholeMatch, language, codeblock) {
1666 | var end = (options.omitExtraWLInCodeBlocks) ? '' : '\n';
1667 |
1668 | // First parse the github code block
1669 | codeblock = showdown.subParser('encodeCode')(codeblock);
1670 | codeblock = showdown.subParser('detab')(codeblock);
1671 | codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
1672 | codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing whitespace
1673 |
1674 | codeblock = '' + codeblock + end + '
';
1675 |
1676 | codeblock = showdown.subParser('hashBlock')(codeblock, options, globals);
1677 |
1678 | // Since GHCodeblocks can be false positives, we need to
1679 | // store the primitive text and the parsed text in a global var,
1680 | // and then return a token
1681 | return '\n\n~G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
1682 | });
1683 |
1684 | // attacklab: strip sentinel
1685 | text = text.replace(/~0/, '');
1686 |
1687 | return globals.converter._dispatch('githubCodeBlocks.after', text, options, globals);
1688 | });
1689 |
1690 | showdown.subParser('hashBlock', function (text, options, globals) {
1691 | 'use strict';
1692 | text = text.replace(/(^\n+|\n+$)/g, '');
1693 | return '\n\n~K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\n\n';
1694 | });
1695 |
1696 | showdown.subParser('hashElement', function (text, options, globals) {
1697 | 'use strict';
1698 |
1699 | return function (wholeMatch, m1) {
1700 | var blockText = m1;
1701 |
1702 | // Undo double lines
1703 | blockText = blockText.replace(/\n\n/g, '\n');
1704 | blockText = blockText.replace(/^\n/, '');
1705 |
1706 | // strip trailing blank lines
1707 | blockText = blockText.replace(/\n+$/g, '');
1708 |
1709 | // Replace the element text with a marker ("~KxK" where x is its key)
1710 | blockText = '\n\n~K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\n\n';
1711 |
1712 | return blockText;
1713 | };
1714 | });
1715 |
1716 | showdown.subParser('hashHTMLBlocks', function (text, options, globals) {
1717 | 'use strict';
1718 |
1719 | var blockTags = [
1720 | 'pre',
1721 | 'div',
1722 | 'h1',
1723 | 'h2',
1724 | 'h3',
1725 | 'h4',
1726 | 'h5',
1727 | 'h6',
1728 | 'blockquote',
1729 | 'table',
1730 | 'dl',
1731 | 'ol',
1732 | 'ul',
1733 | 'script',
1734 | 'noscript',
1735 | 'form',
1736 | 'fieldset',
1737 | 'iframe',
1738 | 'math',
1739 | 'style',
1740 | 'section',
1741 | 'header',
1742 | 'footer',
1743 | 'nav',
1744 | 'article',
1745 | 'aside',
1746 | 'address',
1747 | 'audio',
1748 | 'canvas',
1749 | 'figure',
1750 | 'hgroup',
1751 | 'output',
1752 | 'video',
1753 | 'p'
1754 | ],
1755 | repFunc = function (wholeMatch, match, left, right) {
1756 | var txt = wholeMatch;
1757 | // check if this html element is marked as markdown
1758 | // if so, it's contents should be parsed as markdown
1759 | if (left.search(/\bmarkdown\b/) !== -1) {
1760 | txt = left + globals.converter.makeHtml(match) + right;
1761 | }
1762 | return '\n\n~K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
1763 | };
1764 |
1765 | for (var i = 0; i < blockTags.length; ++i) {
1766 | text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^(?: |\\t){0,3}<' + blockTags[i] + '\\b[^>]*>', '', 'gim');
1767 | }
1768 |
1769 | // HR SPECIAL CASE
1770 | text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,
1771 | showdown.subParser('hashElement')(text, options, globals));
1772 |
1773 | // Special case for standalone HTML comments:
1774 | text = text.replace(/()/g,
1775 | showdown.subParser('hashElement')(text, options, globals));
1776 |
1777 | // PHP and ASP-style processor instructions ( and <%...%>)
1778 | text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,
1779 | showdown.subParser('hashElement')(text, options, globals));
1780 | return text;
1781 | });
1782 |
1783 | /**
1784 | * Hash span elements that should not be parsed as markdown
1785 | */
1786 | showdown.subParser('hashHTMLSpans', function (text, config, globals) {
1787 | 'use strict';
1788 |
1789 | var matches = showdown.helper.matchRecursiveRegExp(text, ']*>', '', 'gi');
1790 |
1791 | for (var i = 0; i < matches.length; ++i) {
1792 | text = text.replace(matches[i][0], '~L' + (globals.gHtmlSpans.push(matches[i][0]) - 1) + 'L');
1793 | }
1794 | return text;
1795 | });
1796 |
1797 | /**
1798 | * Unhash HTML spans
1799 | */
1800 | showdown.subParser('unhashHTMLSpans', function (text, config, globals) {
1801 | 'use strict';
1802 |
1803 | for (var i = 0; i < globals.gHtmlSpans.length; ++i) {
1804 | text = text.replace('~L' + i + 'L', globals.gHtmlSpans[i]);
1805 | }
1806 |
1807 | return text;
1808 | });
1809 |
1810 | /**
1811 | * Hash span elements that should not be parsed as markdown
1812 | */
1813 | showdown.subParser('hashPreCodeTags', function (text, config, globals) {
1814 | 'use strict';
1815 |
1816 | var repFunc = function (wholeMatch, match, left, right) {
1817 | // encode html entities
1818 | var codeblock = left + showdown.subParser('encodeCode')(match) + right;
1819 | return '\n\n~G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
1820 | };
1821 |
1822 | text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^(?: |\\t){0,3}]*>\\s*]*>', '^(?: |\\t){0,3}\\s*', 'gim');
1823 | return text;
1824 | });
1825 |
1826 | showdown.subParser('headers', function (text, options, globals) {
1827 | 'use strict';
1828 |
1829 | text = globals.converter._dispatch('headers.before', text, options, globals);
1830 |
1831 | var prefixHeader = options.prefixHeaderId,
1832 | headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),
1833 |
1834 | // Set text-style headers:
1835 | // Header 1
1836 | // ========
1837 | //
1838 | // Header 2
1839 | // --------
1840 | //
1841 | setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n={2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n=+[ \t]*\n+/gm,
1842 | setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n-{2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n-+[ \t]*\n+/gm;
1843 |
1844 | text = text.replace(setextRegexH1, function (wholeMatch, m1) {
1845 |
1846 | var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
1847 | hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
1848 | hLevel = headerLevelStart,
1849 | hashBlock = '' + spanGamut + '';
1850 | return showdown.subParser('hashBlock')(hashBlock, options, globals);
1851 | });
1852 |
1853 | text = text.replace(setextRegexH2, function (matchFound, m1) {
1854 | var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
1855 | hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
1856 | hLevel = headerLevelStart + 1,
1857 | hashBlock = '' + spanGamut + '';
1858 | return showdown.subParser('hashBlock')(hashBlock, options, globals);
1859 | });
1860 |
1861 | // atx-style headers:
1862 | // # Header 1
1863 | // ## Header 2
1864 | // ## Header 2 with closing hashes ##
1865 | // ...
1866 | // ###### Header 6
1867 | //
1868 | text = text.replace(/^(#{1,6})[ \t]*(.+?)[ \t]*#*\n+/gm, function (wholeMatch, m1, m2) {
1869 | var span = showdown.subParser('spanGamut')(m2, options, globals),
1870 | hID = (options.noHeaderId) ? '' : ' id="' + headerId(m2) + '"',
1871 | hLevel = headerLevelStart - 1 + m1.length,
1872 | header = '' + span + '';
1873 |
1874 | return showdown.subParser('hashBlock')(header, options, globals);
1875 | });
1876 |
1877 | function headerId(m) {
1878 | var title, escapedId = m.replace(/[^\w]/g, '').toLowerCase();
1879 |
1880 | if (globals.hashLinkCounts[escapedId]) {
1881 | title = escapedId + '-' + (globals.hashLinkCounts[escapedId]++);
1882 | } else {
1883 | title = escapedId;
1884 | globals.hashLinkCounts[escapedId] = 1;
1885 | }
1886 |
1887 | // Prefix id to prevent causing inadvertent pre-existing style matches.
1888 | if (prefixHeader === true) {
1889 | prefixHeader = 'section';
1890 | }
1891 |
1892 | if (showdown.helper.isString(prefixHeader)) {
1893 | return prefixHeader + title;
1894 | }
1895 | return title;
1896 | }
1897 |
1898 | text = globals.converter._dispatch('headers.after', text, options, globals);
1899 | return text;
1900 | });
1901 |
1902 | /**
1903 | * Turn Markdown image shortcuts into ![]()
tags.
1904 | */
1905 | showdown.subParser('images', function (text, options, globals) {
1906 | 'use strict';
1907 |
1908 | text = globals.converter._dispatch('images.before', text, options, globals);
1909 |
1910 | var inlineRegExp = /!\[(.*?)]\s?\([ \t]*()?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(['"])(.*?)\6[ \t]*)?\)/g,
1911 | referenceRegExp = /!\[([^\]]*?)] ?(?:\n *)?\[(.*?)]()()()()()/g;
1912 |
1913 | function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {
1914 |
1915 | var gUrls = globals.gUrls,
1916 | gTitles = globals.gTitles,
1917 | gDims = globals.gDimensions;
1918 |
1919 | linkId = linkId.toLowerCase();
1920 |
1921 | if (!title) {
1922 | title = '';
1923 | }
1924 |
1925 | if (url === '' || url === null) {
1926 | if (linkId === '' || linkId === null) {
1927 | // lower-case and turn embedded newlines into spaces
1928 | linkId = altText.toLowerCase().replace(/ ?\n/g, ' ');
1929 | }
1930 | url = '#' + linkId;
1931 |
1932 | if (!showdown.helper.isUndefined(gUrls[linkId])) {
1933 | url = gUrls[linkId];
1934 | if (!showdown.helper.isUndefined(gTitles[linkId])) {
1935 | title = gTitles[linkId];
1936 | }
1937 | if (!showdown.helper.isUndefined(gDims[linkId])) {
1938 | width = gDims[linkId].width;
1939 | height = gDims[linkId].height;
1940 | }
1941 | } else {
1942 | return wholeMatch;
1943 | }
1944 | }
1945 |
1946 | altText = altText.replace(/"/g, '"');
1947 | altText = showdown.helper.escapeCharacters(altText, '*_', false);
1948 | url = showdown.helper.escapeCharacters(url, '*_', false);
1949 | var result = '
x "optional title")
1973 | text = text.replace(inlineRegExp, writeImageTag);
1974 |
1975 | text = globals.converter._dispatch('images.after', text, options, globals);
1976 | return text;
1977 | });
1978 |
1979 | showdown.subParser('italicsAndBold', function (text, options, globals) {
1980 | 'use strict';
1981 |
1982 | text = globals.converter._dispatch('italicsAndBold.before', text, options, globals);
1983 |
1984 | if (options.literalMidWordUnderscores) {
1985 | //underscores
1986 | // Since we are consuming a \s character, we need to add it
1987 | text = text.replace(/(^|\s|>|\b)__(?=\S)([\s\S]+?)__(?=\b|<|\s|$)/gm, '$1$2');
1988 | text = text.replace(/(^|\s|>|\b)_(?=\S)([\s\S]+?)_(?=\b|<|\s|$)/gm, '$1$2');
1989 | //asterisks
1990 | text = text.replace(/(\*\*)(?=\S)([^\r]*?\S[*]*)\1/g, '$2');
1991 | text = text.replace(/(\*)(?=\S)([^\r]*?\S)\1/g, '$2');
1992 |
1993 | } else {
1994 | // must go first:
1995 | text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[*_]*)\1/g, '$2');
1996 | text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g, '$2');
1997 | }
1998 |
1999 | text = globals.converter._dispatch('italicsAndBold.after', text, options, globals);
2000 | return text;
2001 | });
2002 |
2003 | /**
2004 | * Form HTML ordered (numbered) and unordered (bulleted) lists.
2005 | */
2006 | showdown.subParser('lists', function (text, options, globals) {
2007 | 'use strict';
2008 |
2009 | text = globals.converter._dispatch('lists.before', text, options, globals);
2010 | /**
2011 | * Process the contents of a single ordered or unordered list, splitting it
2012 | * into individual list items.
2013 | * @param {string} listStr
2014 | * @param {boolean} trimTrailing
2015 | * @returns {string}
2016 | */
2017 | function processListItems (listStr, trimTrailing) {
2018 | // The $g_list_level global keeps track of when we're inside a list.
2019 | // Each time we enter a list, we increment it; when we leave a list,
2020 | // we decrement. If it's zero, we're not in a list anymore.
2021 | //
2022 | // We do this because when we're not inside a list, we want to treat
2023 | // something like this:
2024 | //
2025 | // I recommend upgrading to version
2026 | // 8. Oops, now this line is treated
2027 | // as a sub-list.
2028 | //
2029 | // As a single paragraph, despite the fact that the second line starts
2030 | // with a digit-period-space sequence.
2031 | //
2032 | // Whereas when we're inside a list (or sub-list), that line will be
2033 | // treated as the start of a sub-list. What a kludge, huh? This is
2034 | // an aspect of Markdown's syntax that's hard to parse perfectly
2035 | // without resorting to mind-reading. Perhaps the solution is to
2036 | // change the syntax rules such that sub-lists must start with a
2037 | // starting cardinal number; e.g. "1." or "a.".
2038 | globals.gListLevel++;
2039 |
2040 | // trim trailing blank lines:
2041 | listStr = listStr.replace(/\n{2,}$/, '\n');
2042 |
2043 | // attacklab: add sentinel to emulate \z
2044 | listStr += '~0';
2045 |
2046 | var rgx = /(\n)?(^[ \t]*)([*+-]|\d+[.])[ \t]+((\[(x|X| )?])?[ \t]*[^\r]+?(\n{1,2}))(?=\n*(~0|\2([*+-]|\d+[.])[ \t]+))/gm,
2047 | isParagraphed = (/\n[ \t]*\n(?!~0)/.test(listStr));
2048 |
2049 | listStr = listStr.replace(rgx, function (wholeMatch, m1, m2, m3, m4, taskbtn, checked) {
2050 | checked = (checked && checked.trim() !== '');
2051 | var item = showdown.subParser('outdent')(m4, options, globals),
2052 | bulletStyle = '';
2053 |
2054 | // Support for github tasklists
2055 | if (taskbtn && options.tasklists) {
2056 | bulletStyle = ' class="task-list-item" style="list-style-type: none;"';
2057 | item = item.replace(/^[ \t]*\[(x|X| )?]/m, function () {
2058 | var otp = ' -1)) {
2070 | item = showdown.subParser('githubCodeBlocks')(item, options, globals);
2071 | item = showdown.subParser('blockGamut')(item, options, globals);
2072 | } else {
2073 | // Recursion for sub-lists:
2074 | item = showdown.subParser('lists')(item, options, globals);
2075 | item = item.replace(/\n$/, ''); // chomp(item)
2076 | if (isParagraphed) {
2077 | item = showdown.subParser('paragraphs')(item, options, globals);
2078 | } else {
2079 | item = showdown.subParser('spanGamut')(item, options, globals);
2080 | }
2081 | }
2082 | item = '\n' + item + '\n';
2083 | return item;
2084 | });
2085 |
2086 | // attacklab: strip sentinel
2087 | listStr = listStr.replace(/~0/g, '');
2088 |
2089 | globals.gListLevel--;
2090 |
2091 | if (trimTrailing) {
2092 | listStr = listStr.replace(/\s+$/, '');
2093 | }
2094 |
2095 | return listStr;
2096 | }
2097 |
2098 | /**
2099 | * Check and parse consecutive lists (better fix for issue #142)
2100 | * @param {string} list
2101 | * @param {string} listType
2102 | * @param {boolean} trimTrailing
2103 | * @returns {string}
2104 | */
2105 | function parseConsecutiveLists(list, listType, trimTrailing) {
2106 | // check if we caught 2 or more consecutive lists by mistake
2107 | // we use the counterRgx, meaning if listType is UL we look for UL and vice versa
2108 | var counterRxg = (listType === 'ul') ? /^ {0,2}\d+\.[ \t]/gm : /^ {0,2}[*+-][ \t]/gm,
2109 | subLists = [],
2110 | result = '';
2111 |
2112 | if (list.search(counterRxg) !== -1) {
2113 | (function parseCL(txt) {
2114 | var pos = txt.search(counterRxg);
2115 | if (pos !== -1) {
2116 | // slice
2117 | result += '\n\n<' + listType + '>' + processListItems(txt.slice(0, pos), !!trimTrailing) + '\n\n';
2118 |
2119 | // invert counterType and listType
2120 | listType = (listType === 'ul') ? 'ol' : 'ul';
2121 | counterRxg = (listType === 'ul') ? /^ {0,2}\d+\.[ \t]/gm : /^ {0,2}[*+-][ \t]/gm;
2122 |
2123 | //recurse
2124 | parseCL(txt.slice(pos));
2125 | } else {
2126 | result += '\n\n<' + listType + '>' + processListItems(txt, !!trimTrailing) + '\n\n';
2127 | }
2128 | })(list);
2129 | for (var i = 0; i < subLists.length; ++i) {
2130 |
2131 | }
2132 | } else {
2133 | result = '\n\n<' + listType + '>' + processListItems(list, !!trimTrailing) + '\n\n';
2134 | }
2135 |
2136 | return result;
2137 | }
2138 |
2139 | // attacklab: add sentinel to hack around khtml/safari bug:
2140 | // http://bugs.webkit.org/show_bug.cgi?id=11231
2141 | text += '~0';
2142 |
2143 | // Re-usable pattern to match any entire ul or ol list:
2144 | var wholeList = /^(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
2145 |
2146 | if (globals.gListLevel) {
2147 | text = text.replace(wholeList, function (wholeMatch, list, m2) {
2148 | var listType = (m2.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
2149 | return parseConsecutiveLists(list, listType, true);
2150 | });
2151 | } else {
2152 | wholeList = /(\n\n|^\n?)(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
2153 | //wholeList = /(\n\n|^\n?)( {0,3}([*+-]|\d+\.)[ \t]+[\s\S]+?)(?=(~0)|(\n\n(?!\t| {2,}| {0,3}([*+-]|\d+\.)[ \t])))/g;
2154 | text = text.replace(wholeList, function (wholeMatch, m1, list, m3) {
2155 |
2156 | var listType = (m3.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
2157 | return parseConsecutiveLists(list, listType);
2158 | });
2159 | }
2160 |
2161 | // attacklab: strip sentinel
2162 | text = text.replace(/~0/, '');
2163 |
2164 | text = globals.converter._dispatch('lists.after', text, options, globals);
2165 | return text;
2166 | });
2167 |
2168 | /**
2169 | * Remove one level of line-leading tabs or spaces
2170 | */
2171 | showdown.subParser('outdent', function (text) {
2172 | 'use strict';
2173 |
2174 | // attacklab: hack around Konqueror 3.5.4 bug:
2175 | // "----------bug".replace(/^-/g,"") == "bug"
2176 | text = text.replace(/^(\t|[ ]{1,4})/gm, '~0'); // attacklab: g_tab_width
2177 |
2178 | // attacklab: clean up hack
2179 | text = text.replace(/~0/g, '');
2180 |
2181 | return text;
2182 | });
2183 |
2184 | /**
2185 | *
2186 | */
2187 | showdown.subParser('paragraphs', function (text, options, globals) {
2188 | 'use strict';
2189 |
2190 | text = globals.converter._dispatch('paragraphs.before', text, options, globals);
2191 | // Strip leading and trailing lines:
2192 | text = text.replace(/^\n+/g, '');
2193 | text = text.replace(/\n+$/g, '');
2194 |
2195 | var grafs = text.split(/\n{2,}/g),
2196 | grafsOut = [],
2197 | end = grafs.length; // Wrap tags
2198 |
2199 | for (var i = 0; i < end; i++) {
2200 | var str = grafs[i];
2201 | // if this is an HTML marker, copy it
2202 | if (str.search(/~(K|G)(\d+)\1/g) >= 0) {
2203 | grafsOut.push(str);
2204 | } else {
2205 | str = showdown.subParser('spanGamut')(str, options, globals);
2206 | str = str.replace(/^([ \t]*)/g, '
');
2207 | str += '
';
2208 | grafsOut.push(str);
2209 | }
2210 | }
2211 |
2212 | /** Unhashify HTML blocks */
2213 | end = grafsOut.length;
2214 | for (i = 0; i < end; i++) {
2215 | var blockText = '',
2216 | grafsOutIt = grafsOut[i],
2217 | codeFlag = false;
2218 | // if this is a marker for an html block...
2219 | while (grafsOutIt.search(/~(K|G)(\d+)\1/) >= 0) {
2220 | var delim = RegExp.$1,
2221 | num = RegExp.$2;
2222 |
2223 | if (delim === 'K') {
2224 | blockText = globals.gHtmlBlocks[num];
2225 | } else {
2226 | // we need to check if ghBlock is a false positive
2227 | if (codeFlag) {
2228 | // use encoded version of all text
2229 | blockText = showdown.subParser('encodeCode')(globals.ghCodeBlocks[num].text);
2230 | } else {
2231 | blockText = globals.ghCodeBlocks[num].codeblock;
2232 | }
2233 | }
2234 | blockText = blockText.replace(/\$/g, '$$$$'); // Escape any dollar signs
2235 |
2236 | grafsOutIt = grafsOutIt.replace(/(\n\n)?~(K|G)\d+\2(\n\n)?/, blockText);
2237 | // Check if grafsOutIt is a pre->code
2238 | if (/^]*>\s*]*>/.test(grafsOutIt)) {
2239 | codeFlag = true;
2240 | }
2241 | }
2242 | grafsOut[i] = grafsOutIt;
2243 | }
2244 | text = grafsOut.join('\n\n');
2245 | // Strip leading and trailing lines:
2246 | text = text.replace(/^\n+/g, '');
2247 | text = text.replace(/\n+$/g, '');
2248 | return globals.converter._dispatch('paragraphs.after', text, options, globals);
2249 | });
2250 |
2251 | /**
2252 | * Run extension
2253 | */
2254 | showdown.subParser('runExtension', function (ext, text, options, globals) {
2255 | 'use strict';
2256 |
2257 | if (ext.filter) {
2258 | text = ext.filter(text, globals.converter, options);
2259 |
2260 | } else if (ext.regex) {
2261 | // TODO remove this when old extension loading mechanism is deprecated
2262 | var re = ext.regex;
2263 | if (!re instanceof RegExp) {
2264 | re = new RegExp(re, 'g');
2265 | }
2266 | text = text.replace(re, ext.replace);
2267 | }
2268 |
2269 | return text;
2270 | });
2271 |
2272 | /**
2273 | * These are all the transformations that occur *within* block-level
2274 | * tags like paragraphs, headers, and list items.
2275 | */
2276 | showdown.subParser('spanGamut', function (text, options, globals) {
2277 | 'use strict';
2278 |
2279 | text = globals.converter._dispatch('spanGamut.before', text, options, globals);
2280 | text = showdown.subParser('codeSpans')(text, options, globals);
2281 | text = showdown.subParser('escapeSpecialCharsWithinTagAttributes')(text, options, globals);
2282 | text = showdown.subParser('encodeBackslashEscapes')(text, options, globals);
2283 |
2284 | // Process anchor and image tags. Images must come first,
2285 | // because ![foo][f] looks like an anchor.
2286 | text = showdown.subParser('images')(text, options, globals);
2287 | text = showdown.subParser('anchors')(text, options, globals);
2288 |
2289 | // Make links out of things like ``
2290 | // Must come after _DoAnchors(), because you can use < and >
2291 | // delimiters in inline links like [this]().
2292 | text = showdown.subParser('autoLinks')(text, options, globals);
2293 | text = showdown.subParser('encodeAmpsAndAngles')(text, options, globals);
2294 | text = showdown.subParser('italicsAndBold')(text, options, globals);
2295 | text = showdown.subParser('strikethrough')(text, options, globals);
2296 |
2297 | // Do hard breaks:
2298 | text = text.replace(/ +\n/g, '
\n');
2299 |
2300 | text = globals.converter._dispatch('spanGamut.after', text, options, globals);
2301 | return text;
2302 | });
2303 |
2304 | showdown.subParser('strikethrough', function (text, options, globals) {
2305 | 'use strict';
2306 |
2307 | if (options.strikethrough) {
2308 | text = globals.converter._dispatch('strikethrough.before', text, options, globals);
2309 | text = text.replace(/(?:~T){2}([\s\S]+?)(?:~T){2}/g, '$1');
2310 | text = globals.converter._dispatch('strikethrough.after', text, options, globals);
2311 | }
2312 |
2313 | return text;
2314 | });
2315 |
2316 | /**
2317 | * Strip any lines consisting only of spaces and tabs.
2318 | * This makes subsequent regexs easier to write, because we can
2319 | * match consecutive blank lines with /\n+/ instead of something
2320 | * contorted like /[ \t]*\n+/
2321 | */
2322 | showdown.subParser('stripBlankLines', function (text) {
2323 | 'use strict';
2324 | return text.replace(/^[ \t]+$/mg, '');
2325 | });
2326 |
2327 | /**
2328 | * Strips link definitions from text, stores the URLs and titles in
2329 | * hash references.
2330 | * Link defs are in the form: ^[id]: url "optional title"
2331 | *
2332 | * ^[ ]{0,3}\[(.+)\]: // id = $1 attacklab: g_tab_width - 1
2333 | * [ \t]*
2334 | * \n? // maybe *one* newline
2335 | * [ \t]*
2336 | * ? // url = $2
2337 | * [ \t]*
2338 | * \n? // maybe one newline
2339 | * [ \t]*
2340 | * (?:
2341 | * (\n*) // any lines skipped = $3 attacklab: lookbehind removed
2342 | * ["(]
2343 | * (.+?) // title = $4
2344 | * [")]
2345 | * [ \t]*
2346 | * )? // title is optional
2347 | * (?:\n+|$)
2348 | * /gm,
2349 | * function(){...});
2350 | *
2351 | */
2352 | showdown.subParser('stripLinkDefinitions', function (text, options, globals) {
2353 | 'use strict';
2354 |
2355 | var regex = /^ {0,3}\[(.+)]:[ \t]*\n?[ \t]*?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*\n?[ \t]*(?:(\n*)["|'(](.+?)["|')][ \t]*)?(?:\n+|(?=~0))/gm;
2356 |
2357 | // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
2358 | text += '~0';
2359 |
2360 | text = text.replace(regex, function (wholeMatch, linkId, url, width, height, blankLines, title) {
2361 | linkId = linkId.toLowerCase();
2362 | globals.gUrls[linkId] = showdown.subParser('encodeAmpsAndAngles')(url); // Link IDs are case-insensitive
2363 |
2364 | if (blankLines) {
2365 | // Oops, found blank lines, so it's not a title.
2366 | // Put back the parenthetical statement we stole.
2367 | return blankLines + title;
2368 |
2369 | } else {
2370 | if (title) {
2371 | globals.gTitles[linkId] = title.replace(/"|'/g, '"');
2372 | }
2373 | if (options.parseImgDimensions && width && height) {
2374 | globals.gDimensions[linkId] = {
2375 | width: width,
2376 | height: height
2377 | };
2378 | }
2379 | }
2380 | // Completely remove the definition from the text
2381 | return '';
2382 | });
2383 |
2384 | // attacklab: strip sentinel
2385 | text = text.replace(/~0/, '');
2386 |
2387 | return text;
2388 | });
2389 |
2390 | showdown.subParser('tables', function (text, options, globals) {
2391 | 'use strict';
2392 |
2393 | if (!options.tables) {
2394 | return text;
2395 | }
2396 |
2397 | var tableRgx = /^[ \t]{0,3}\|?.+\|.+\n[ \t]{0,3}\|?[ \t]*:?[ \t]*(?:-|=){2,}[ \t]*:?[ \t]*\|[ \t]*:?[ \t]*(?:-|=){2,}[\s\S]+?(?:\n\n|~0)/gm;
2398 |
2399 | function parseStyles(sLine) {
2400 | if (/^:[ \t]*--*$/.test(sLine)) {
2401 | return ' style="text-align:left;"';
2402 | } else if (/^--*[ \t]*:[ \t]*$/.test(sLine)) {
2403 | return ' style="text-align:right;"';
2404 | } else if (/^:[ \t]*--*[ \t]*:$/.test(sLine)) {
2405 | return ' style="text-align:center;"';
2406 | } else {
2407 | return '';
2408 | }
2409 | }
2410 |
2411 | function parseHeaders(header, style) {
2412 | var id = '';
2413 | header = header.trim();
2414 | if (options.tableHeaderId) {
2415 | id = ' id="' + header.replace(/ /g, '_').toLowerCase() + '"';
2416 | }
2417 | header = showdown.subParser('spanGamut')(header, options, globals);
2418 |
2419 | return '' + header + '\n';
2420 | }
2421 |
2422 | function parseCells(cell, style) {
2423 | var subText = showdown.subParser('spanGamut')(cell, options, globals);
2424 | return '' + subText + '\n';
2425 | }
2426 |
2427 | function buildTable(headers, cells) {
2428 | var tb = '\n\n\n',
2429 | tblLgn = headers.length;
2430 |
2431 | for (var i = 0; i < tblLgn; ++i) {
2432 | tb += headers[i];
2433 | }
2434 | tb += '
\n\n\n';
2435 |
2436 | for (i = 0; i < cells.length; ++i) {
2437 | tb += '\n';
2438 | for (var ii = 0; ii < tblLgn; ++ii) {
2439 | tb += cells[i][ii];
2440 | }
2441 | tb += '
\n';
2442 | }
2443 | tb += '\n
\n';
2444 | return tb;
2445 | }
2446 |
2447 | text = globals.converter._dispatch('tables.before', text, options, globals);
2448 |
2449 | text = text.replace(tableRgx, function (rawTable) {
2450 |
2451 | var i, tableLines = rawTable.split('\n');
2452 |
2453 | // strip wrong first and last column if wrapped tables are used
2454 | for (i = 0; i < tableLines.length; ++i) {
2455 | if (/^[ \t]{0,3}\|/.test(tableLines[i])) {
2456 | tableLines[i] = tableLines[i].replace(/^[ \t]{0,3}\|/, '');
2457 | }
2458 | if (/\|[ \t]*$/.test(tableLines[i])) {
2459 | tableLines[i] = tableLines[i].replace(/\|[ \t]*$/, '');
2460 | }
2461 | }
2462 |
2463 | var rawHeaders = tableLines[0].split('|').map(function (s) { return s.trim();}),
2464 | rawStyles = tableLines[1].split('|').map(function (s) { return s.trim();}),
2465 | rawCells = [],
2466 | headers = [],
2467 | styles = [],
2468 | cells = [];
2469 |
2470 | tableLines.shift();
2471 | tableLines.shift();
2472 |
2473 | for (i = 0; i < tableLines.length; ++i) {
2474 | if (tableLines[i].trim() === '') {
2475 | continue;
2476 | }
2477 | rawCells.push(
2478 | tableLines[i]
2479 | .split('|')
2480 | .map(function (s) {
2481 | return s.trim();
2482 | })
2483 | );
2484 | }
2485 |
2486 | if (rawHeaders.length < rawStyles.length) {
2487 | return rawTable;
2488 | }
2489 |
2490 | for (i = 0; i < rawStyles.length; ++i) {
2491 | styles.push(parseStyles(rawStyles[i]));
2492 | }
2493 |
2494 | for (i = 0; i < rawHeaders.length; ++i) {
2495 | if (showdown.helper.isUndefined(styles[i])) {
2496 | styles[i] = '';
2497 | }
2498 | headers.push(parseHeaders(rawHeaders[i], styles[i]));
2499 | }
2500 |
2501 | for (i = 0; i < rawCells.length; ++i) {
2502 | var row = [];
2503 | for (var ii = 0; ii < headers.length; ++ii) {
2504 | if (showdown.helper.isUndefined(rawCells[i][ii])) {
2505 |
2506 | }
2507 | row.push(parseCells(rawCells[i][ii], styles[ii]));
2508 | }
2509 | cells.push(row);
2510 | }
2511 |
2512 | return buildTable(headers, cells);
2513 | });
2514 |
2515 | text = globals.converter._dispatch('tables.after', text, options, globals);
2516 |
2517 | return text;
2518 | });
2519 |
2520 | /**
2521 | * Swap back in all the special characters we've hidden.
2522 | */
2523 | showdown.subParser('unescapeSpecialChars', function (text) {
2524 | 'use strict';
2525 |
2526 | text = text.replace(/~E(\d+)E/g, function (wholeMatch, m1) {
2527 | var charCodeToReplace = parseInt(m1);
2528 | return String.fromCharCode(charCodeToReplace);
2529 | });
2530 | return text;
2531 | });
2532 | module.exports = showdown;
2533 |
--------------------------------------------------------------------------------
/wxParse/wxDiscode.js:
--------------------------------------------------------------------------------
1 | // HTML 支持的数学符号
2 | function strNumDiscode(str){
3 | str = str.replace(/∀/g, '∀');
4 | str = str.replace(/∂/g, '∂');
5 | str = str.replace(/&exists;/g, '∃');
6 | str = str.replace(/∅/g, '∅');
7 | str = str.replace(/∇/g, '∇');
8 | str = str.replace(/∈/g, '∈');
9 | str = str.replace(/∉/g, '∉');
10 | str = str.replace(/∋/g, '∋');
11 | str = str.replace(/∏/g, '∏');
12 | str = str.replace(/∑/g, '∑');
13 | str = str.replace(/−/g, '−');
14 | str = str.replace(/∗/g, '∗');
15 | str = str.replace(/√/g, '√');
16 | str = str.replace(/∝/g, '∝');
17 | str = str.replace(/∞/g, '∞');
18 | str = str.replace(/∠/g, '∠');
19 | str = str.replace(/∧/g, '∧');
20 | str = str.replace(/∨/g, '∨');
21 | str = str.replace(/∩/g, '∩');
22 | str = str.replace(/∩/g, '∪');
23 | str = str.replace(/∫/g, '∫');
24 | str = str.replace(/∴/g, '∴');
25 | str = str.replace(/∼/g, '∼');
26 | str = str.replace(/≅/g, '≅');
27 | str = str.replace(/≈/g, '≈');
28 | str = str.replace(/≠/g, '≠');
29 | str = str.replace(/≤/g, '≤');
30 | str = str.replace(/≥/g, '≥');
31 | str = str.replace(/⊂/g, '⊂');
32 | str = str.replace(/⊃/g, '⊃');
33 | str = str.replace(/⊄/g, '⊄');
34 | str = str.replace(/⊆/g, '⊆');
35 | str = str.replace(/⊇/g, '⊇');
36 | str = str.replace(/⊕/g, '⊕');
37 | str = str.replace(/⊗/g, '⊗');
38 | str = str.replace(/⊥/g, '⊥');
39 | str = str.replace(/⋅/g, '⋅');
40 | return str;
41 | }
42 |
43 | //HTML 支持的希腊字母
44 | function strGreeceDiscode(str){
45 | str = str.replace(/Α/g, 'Α');
46 | str = str.replace(/Β/g, 'Β');
47 | str = str.replace(/Γ/g, 'Γ');
48 | str = str.replace(/Δ/g, 'Δ');
49 | str = str.replace(/Ε/g, 'Ε');
50 | str = str.replace(/Ζ/g, 'Ζ');
51 | str = str.replace(/Η/g, 'Η');
52 | str = str.replace(/Θ/g, 'Θ');
53 | str = str.replace(/Ι/g, 'Ι');
54 | str = str.replace(/Κ/g, 'Κ');
55 | str = str.replace(/Λ/g, 'Λ');
56 | str = str.replace(/Μ/g, 'Μ');
57 | str = str.replace(/Ν/g, 'Ν');
58 | str = str.replace(/Ξ/g, 'Ν');
59 | str = str.replace(/Ο/g, 'Ο');
60 | str = str.replace(/Π/g, 'Π');
61 | str = str.replace(/Ρ/g, 'Ρ');
62 | str = str.replace(/Σ/g, 'Σ');
63 | str = str.replace(/Τ/g, 'Τ');
64 | str = str.replace(/Υ/g, 'Υ');
65 | str = str.replace(/Φ/g, 'Φ');
66 | str = str.replace(/Χ/g, 'Χ');
67 | str = str.replace(/Ψ/g, 'Ψ');
68 | str = str.replace(/Ω/g, 'Ω');
69 |
70 | str = str.replace(/α/g, 'α');
71 | str = str.replace(/β/g, 'β');
72 | str = str.replace(/γ/g, 'γ');
73 | str = str.replace(/δ/g, 'δ');
74 | str = str.replace(/ε/g, 'ε');
75 | str = str.replace(/ζ/g, 'ζ');
76 | str = str.replace(/η/g, 'η');
77 | str = str.replace(/θ/g, 'θ');
78 | str = str.replace(/ι/g, 'ι');
79 | str = str.replace(/κ/g, 'κ');
80 | str = str.replace(/λ/g, 'λ');
81 | str = str.replace(/μ/g, 'μ');
82 | str = str.replace(/ν/g, 'ν');
83 | str = str.replace(/ξ/g, 'ξ');
84 | str = str.replace(/ο/g, 'ο');
85 | str = str.replace(/π/g, 'π');
86 | str = str.replace(/ρ/g, 'ρ');
87 | str = str.replace(/ς/g, 'ς');
88 | str = str.replace(/σ/g, 'σ');
89 | str = str.replace(/τ/g, 'τ');
90 | str = str.replace(/υ/g, 'υ');
91 | str = str.replace(/φ/g, 'φ');
92 | str = str.replace(/χ/g, 'χ');
93 | str = str.replace(/ψ/g, 'ψ');
94 | str = str.replace(/ω/g, 'ω');
95 | str = str.replace(/ϑ/g, 'ϑ');
96 | str = str.replace(/ϒ/g, 'ϒ');
97 | str = str.replace(/ϖ/g, 'ϖ');
98 | str = str.replace(/·/g, '·');
99 | return str;
100 | }
101 |
102 | //
103 |
104 | function strcharacterDiscode(str){
105 | // 加入常用解析
106 | str = str.replace(/ /g, ' ');
107 | str = str.replace(/"/g, "'");
108 | str = str.replace(/&/g, '&');
109 | // str = str.replace(/</g, '‹');
110 | // str = str.replace(/>/g, '›');
111 |
112 | str = str.replace(/</g, '<');
113 | str = str.replace(/>/g, '>');
114 | str = str.replace(/•/g, '•');
115 |
116 | return str;
117 | }
118 |
119 | // HTML 支持的其他实体
120 | function strOtherDiscode(str){
121 | str = str.replace(/Œ/g, 'Œ');
122 | str = str.replace(/œ/g, 'œ');
123 | str = str.replace(/Š/g, 'Š');
124 | str = str.replace(/š/g, 'š');
125 | str = str.replace(/Ÿ/g, 'Ÿ');
126 | str = str.replace(/ƒ/g, 'ƒ');
127 | str = str.replace(/ˆ/g, 'ˆ');
128 | str = str.replace(/˜/g, '˜');
129 | str = str.replace(/ /g, '');
130 | str = str.replace(/ /g, '');
131 | str = str.replace(/ /g, '');
132 | str = str.replace(//g, '');
133 | str = str.replace(//g, '');
134 | str = str.replace(//g, '');
135 | str = str.replace(//g, '');
136 | str = str.replace(/–/g, '–');
137 | str = str.replace(/—/g, '—');
138 | str = str.replace(/‘/g, '‘');
139 | str = str.replace(/’/g, '’');
140 | str = str.replace(/‚/g, '‚');
141 | str = str.replace(/“/g, '“');
142 | str = str.replace(/”/g, '”');
143 | str = str.replace(/„/g, '„');
144 | str = str.replace(/†/g, '†');
145 | str = str.replace(/‡/g, '‡');
146 | str = str.replace(/•/g, '•');
147 | str = str.replace(/…/g, '…');
148 | str = str.replace(/‰/g, '‰');
149 | str = str.replace(/′/g, '′');
150 | str = str.replace(/″/g, '″');
151 | str = str.replace(/‹/g, '‹');
152 | str = str.replace(/›/g, '›');
153 | str = str.replace(/‾/g, '‾');
154 | str = str.replace(/€/g, '€');
155 | str = str.replace(/™/g, '™');
156 |
157 | str = str.replace(/←/g, '←');
158 | str = str.replace(/↑/g, '↑');
159 | str = str.replace(/→/g, '→');
160 | str = str.replace(/↓/g, '↓');
161 | str = str.replace(/↔/g, '↔');
162 | str = str.replace(/↵/g, '↵');
163 | str = str.replace(/⌈/g, '⌈');
164 | str = str.replace(/⌉/g, '⌉');
165 |
166 | str = str.replace(/⌊/g, '⌊');
167 | str = str.replace(/⌋/g, '⌋');
168 | str = str.replace(/◊/g, '◊');
169 | str = str.replace(/♠/g, '♠');
170 | str = str.replace(/♣/g, '♣');
171 | str = str.replace(/♥/g, '♥');
172 |
173 | str = str.replace(/♦/g, '♦');
174 | str = str.replace(/'/g, '\'');
175 | return str;
176 | }
177 |
178 | function strMoreDiscode(str){
179 | str = str.replace(/\r\n/g,"");
180 | str = str.replace(/\n/g,"");
181 |
182 | str = str.replace(/code/g,"wxxxcode-style");
183 | return str;
184 | }
185 |
186 | function strDiscode(str){
187 | str = strNumDiscode(str);
188 | str = strGreeceDiscode(str);
189 | str = strcharacterDiscode(str);
190 | str = strOtherDiscode(str);
191 | str = strMoreDiscode(str);
192 | return str;
193 | }
194 | function urlToHttpUrl(url,rep){
195 |
196 | var patt1 = new RegExp("^//");
197 | var result = patt1.test(url);
198 | if(result){
199 | url = rep+":"+url;
200 | }
201 | return url;
202 | }
203 |
204 | module.exports = {
205 | strDiscode:strDiscode,
206 | urlToHttpUrl:urlToHttpUrl
207 | }
--------------------------------------------------------------------------------
/wxParse/wxParse.js:
--------------------------------------------------------------------------------
1 | /**
2 | * author: Di (微信小程序开发工程师)
3 | * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
4 | * 垂直微信小程序开发交流社区
5 | *
6 | * github地址: https://github.com/icindy/wxParse
7 | *
8 | * for: 微信小程序富文本解析
9 | * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
10 | */
11 |
12 | /**
13 | * utils函数引入
14 | **/
15 | import showdown from './showdown.js';
16 | import HtmlToJson from './html2json.js';
17 | /**
18 | * 配置及公有属性
19 | **/
20 | var realWindowWidth = 0;
21 | var realWindowHeight = 0;
22 | wx.getSystemInfo({
23 | success: function (res) {
24 | realWindowWidth = res.windowWidth
25 | realWindowHeight = res.windowHeight
26 | }
27 | })
28 | /**
29 | * 主函数入口区
30 | **/
31 | function wxParse(bindName = 'wxParseData', type='html', data='数据不能为空
', target,imagePadding) {
32 | var that = target;
33 | var transData = {};//存放转化后的数据
34 | if (type == 'html') {
35 | transData = HtmlToJson.html2json(data, bindName);
36 | console.log(JSON.stringify(transData, ' ', ' '));
37 | } else if (type == 'md' || type == 'markdown') {
38 | var converter = new showdown.Converter();
39 | var html = converter.makeHtml(data);
40 | transData = HtmlToJson.html2json(html, bindName);
41 | console.log(JSON.stringify(transData, ' ', ' '));
42 | }
43 | transData.view = {};
44 | transData.view.imagePadding = 0;
45 | if(typeof(imagePadding) != 'undefined'){
46 | transData.view.imagePadding = imagePadding
47 | }
48 | var bindData = {};
49 | bindData[bindName] = transData;
50 | that.setData(bindData)
51 | that.wxParseImgLoad = wxParseImgLoad;
52 | that.wxParseImgTap = wxParseImgTap;
53 | }
54 | // 图片点击事件
55 | function wxParseImgTap(e) {
56 | var that = this;
57 | var nowImgUrl = e.target.dataset.src;
58 | var tagFrom = e.target.dataset.from;
59 | if (typeof (tagFrom) != 'undefined' && tagFrom.length > 0) {
60 | wx.previewImage({
61 | current: nowImgUrl, // 当前显示图片的http链接
62 | urls: that.data[tagFrom].imageUrls // 需要预览的图片http链接列表
63 | })
64 | }
65 | }
66 |
67 | /**
68 | * 图片视觉宽高计算函数区
69 | **/
70 | function wxParseImgLoad(e) {
71 | var that = this;
72 | var tagFrom = e.target.dataset.from;
73 | var idx = e.target.dataset.idx;
74 | if (typeof (tagFrom) != 'undefined' && tagFrom.length > 0) {
75 | calMoreImageInfo(e, idx, that, tagFrom)
76 | }
77 | }
78 | // 假循环获取计算图片视觉最佳宽高
79 | function calMoreImageInfo(e, idx, that, bindName) {
80 | var temData = that.data[bindName];
81 | if (!temData || temData.images.length == 0) {
82 | return;
83 | }
84 | var temImages = temData.images;
85 | //因为无法获取view宽度 需要自定义padding进行计算，稍后处理
86 | var recal = wxAutoImageCal(e.detail.width, e.detail.height,that,bindName);
87 | // temImages[idx].width = recal.imageWidth;
88 | // temImages[idx].height = recal.imageheight;
89 | // temData.images = temImages;
90 | // var bindData = {};
91 | // bindData[bindName] = temData;
92 | // that.setData(bindData);
93 | var index = temImages[idx].index
94 | var key = `${bindName}`
95 | for (var i of index.split('.')) key+=`.nodes[${i}]`
96 | var keyW = key + '.width'
97 | var keyH = key + '.height'
98 | that.setData({
99 | [keyW]: recal.imageWidth,
100 | [keyH]: recal.imageheight,
101 | })
102 | }
103 |
104 | // 计算视觉优先的图片宽高
105 | function wxAutoImageCal(originalWidth, originalHeight,that,bindName) {
106 | //获取图片的原始长宽
107 | var windowWidth = 0, windowHeight = 0;
108 | var autoWidth = 0, autoHeight = 0;
109 | var results = {};
110 | var padding = that.data[bindName].view.imagePadding;
111 | windowWidth = realWindowWidth-2*padding;
112 | windowHeight = realWindowHeight;
113 | //判断按照那种方式进行缩放
114 | // console.log("windowWidth" + windowWidth);
115 | if (originalWidth > windowWidth) {//在图片width大于手机屏幕width时候
116 | autoWidth = windowWidth;
117 | // console.log("autoWidth" + autoWidth);
118 | autoHeight = (autoWidth * originalHeight) / originalWidth;
119 | // console.log("autoHeight" + autoHeight);
120 | results.imageWidth = autoWidth;
121 | results.imageheight = autoHeight;
122 | } else {//否则展示原来的数据
123 | results.imageWidth = originalWidth;
124 | results.imageheight = originalHeight;
125 | }
126 | return results;
127 | }
128 |
129 | function wxParseTemArray(temArrayName,bindNameReg,total,that){
130 | var array = [];
131 | var temData = that.data;
132 | var obj = null;
133 | for(var i = 0; i < total; i++){
134 | var simArr = temData[bindNameReg+i].nodes;
135 | array.push(simArr);
136 | }
137 |
138 | temArrayName = temArrayName || 'wxParseTemArray';
139 | obj = JSON.parse('{"'+ temArrayName +'":""}');
140 | obj[temArrayName] = array;
141 | that.setData(obj);
142 | }
143 |
144 | /**
145 | * 配置emojis
146 | *
147 | */
148 |
149 | function emojisInit(reg='',baseSrc="/wxParse/emojis/",emojis){
150 | HtmlToJson.emojisInit(reg,baseSrc,emojis);
151 | }
152 |
153 | module.exports = {
154 | wxParse: wxParse,
155 | wxParseTemArray:wxParseTemArray,
156 | emojisInit:emojisInit
157 | }
158 |
159 |
160 |
--------------------------------------------------------------------------------
/wxParse/wxParse.wxml:
--------------------------------------------------------------------------------
1 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
23 |
24 |
25 |
26 |
27 |
28 | {{item.text}}
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 | \n
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
198 |
199 |
200 |
201 |
202 |
203 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
215 |
216 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 |
232 |
233 |
234 |
235 |
236 |
237 |
238 |
239 |
240 |
241 |
242 |
243 |
244 |
245 |
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
262 |
263 |
264 |
265 |
266 |
267 |
268 |
269 |
270 |
271 |
272 |
273 |
274 |
275 |
276 |
277 |
278 |
279 |
280 |
281 |
282 |
283 |
284 |
285 |
286 |
287 |
288 |
289 |
290 |
291 |
292 |
297 |
298 |
299 |
300 |
301 |
302 |
303 |
304 |
305 |
306 |
307 |
308 |
309 |
310 |
311 |
312 |
313 |
314 |
315 |
316 |
317 |
318 |
319 |
320 |
321 |
322 |
323 |
324 |
325 |
326 |
327 |
328 |
329 |
330 |
331 |
332 |
333 |
334 |
335 |
336 |
337 |
338 |
339 |
340 |
341 |
342 |
343 |
344 |
345 |
346 |
347 |
348 |
349 |
350 |
351 |
352 |
353 |
354 |
355 |
356 |
357 |
358 |
359 |
360 |
361 |
362 |
363 |
364 |
365 |
366 |
367 |
368 |
373 |
374 |
375 |
376 |
377 |
378 |
379 |
380 |
381 |
382 |
383 |
384 |
385 |
386 |
387 |
388 |
389 |
390 |
391 |
392 |
393 |
394 |
395 |
396 |
397 |
398 |
399 |
400 |
401 |
402 |
403 |
404 |
405 |
406 |
407 |
408 |
409 |
410 |
411 |
412 |
413 |
414 |
415 |
416 |
417 |
418 |
419 |
420 |
421 |
422 |
423 |
424 |
425 |
426 |
427 |
428 |
429 |
430 |
431 |
432 |
433 |
434 |
435 |
436 |
437 |
438 |
439 |
440 |
441 |
442 |
443 |
444 |
449 |
450 |
451 |
452 |
453 |
454 |
455 |
456 |
457 |
458 |
459 |
460 |
461 |
462 |
463 |
464 |
465 |
466 |
467 |
468 |
469 |
470 |
471 |
472 |
473 |
474 |
475 |
476 |
477 |
478 |
479 |
480 |
481 |
482 |
483 |
484 |
485 |
486 |
487 |
488 |
489 |
490 |
491 |
492 |
493 |
494 |
495 |
496 |
497 |
498 |
499 |
500 |
501 |
502 |
503 |
504 |
505 |
506 |
507 |
508 |
509 |
510 |
511 |
512 |
513 |
514 |
515 |
516 |
517 |
518 |
519 |
520 |
525 |
526 |
527 |
528 |
529 |
530 |
531 |
532 |
533 |
534 |
535 |
536 |
537 |
538 |
539 |
540 |
541 |
542 |
543 |
544 |
545 |
546 |
547 |
548 |
549 |
550 |
551 |
552 |
553 |
554 |
555 |
556 |
557 |
558 |
559 |
560 |
561 |
562 |
563 |
564 |
565 |
566 |
567 |
568 |
569 |
570 |
571 |
572 |
573 |
574 |
575 |
576 |
577 |
578 |
579 |
580 |
581 |
582 |
583 |
584 |
585 |
586 |
587 |
588 |
589 |
590 |
591 |
592 |
593 |
594 |
595 |
600 |
601 |
602 |
603 |
604 |
605 |
606 |
607 |
608 |
609 |
610 |
611 |
612 |
613 |
614 |
615 |
616 |
617 |
618 |
619 |
620 |
621 |
622 |
623 |
624 |
625 |
626 |
627 |
628 |
629 |
630 |
631 |
632 |
633 |
634 |
635 |
636 |
637 |
638 |
639 |
640 |
641 |
642 |
643 |
644 |
645 |
646 |
647 |
648 |
649 |
650 |
651 |
652 |
653 |
654 |
655 |
656 |
657 |
658 |
659 |
660 |
661 |
662 |
663 |
664 |
665 |
666 |
667 |
668 |
669 |
670 |
671 |
676 |
677 |
678 |
679 |
680 |
681 |
682 |
683 |
684 |
685 |
686 |
687 |
688 |
689 |
690 |
691 |
692 |
693 |
694 |
695 |
696 |
697 |
698 |
699 |
700 |
701 |
702 |
703 |
704 |
705 |
706 |
707 |
708 |
709 |
710 |
711 |
712 |
713 |
714 |
715 |
716 |
717 |
718 |
719 |
720 |
721 |
722 |
723 |
724 |
725 |
726 |
727 |
728 |
729 |
730 |
731 |
732 |
733 |
734 |
735 |
736 |
737 |
738 |
739 |
740 |
741 |
742 |
743 |
744 |
745 |
746 |
747 |
752 |
753 |
754 |
755 |
756 |
757 |
758 |
759 |
760 |
761 |
762 |
763 |
764 |
765 |
766 |
767 |
768 |
769 |
770 |
771 |
772 |
773 |
774 |
775 |
776 |
777 |
778 |
779 |
780 |
781 |
782 |
783 |
784 |
785 |
786 |
787 |
788 |
789 |
790 |
791 |
792 |
793 |
794 |
795 |
796 |
797 |
798 |
799 |
800 |
801 |
802 |
803 |
804 |
805 |
806 |
807 |
808 |
809 |
810 |
811 |
812 |
813 |
814 |
815 |
816 |
817 |
818 |
819 |
820 |
821 |
822 |
823 |
828 |
829 |
830 |
831 |
832 |
833 |
834 |
835 |
836 |
837 |
838 |
839 |
840 |
841 |
842 |
843 |
844 |
845 |
846 |
847 |
848 |
849 |
850 |
851 |
852 |
853 |
854 |
855 |
856 |
857 |
858 |
859 |
860 |
861 |
862 |
863 |
864 |
865 |
866 |
867 |
868 |
869 |
870 |
871 |
872 |
873 |
874 |
875 |
876 |
877 |
878 |
879 |
880 |
881 |
882 |
883 |
884 |
885 |
886 |
887 |
888 |
889 |
890 |
891 |
892 |
893 |
894 |
895 |
896 |
897 |
898 |
899 |
904 |
905 |
906 |
907 |
908 |
909 |
910 |
911 |
912 |
913 |
914 |
915 |
916 |
917 |
918 |
919 |
920 |
921 |
922 |
923 |
924 |
925 |
926 |
927 |
928 |
929 |
930 |
931 |
932 |
933 |
934 |
935 |
936 |
937 |
938 |
939 |
940 |
941 |
942 |
943 |
944 |
945 |
946 |
947 |
948 |
949 |
950 |
951 |
952 |
953 |
954 |
955 |
956 |
957 |
958 |
959 |
960 |
961 |
962 |
963 |
964 |
965 |
966 |
967 |
--------------------------------------------------------------------------------
/wxParse/wxParse.wxss:
--------------------------------------------------------------------------------
1 |
2 | /**
3 | * author: Di (微信小程序开发工程师)
4 | * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
5 | * 垂直微信小程序开发交流社区
6 | *
7 | * github地址: https://github.com/icindy/wxParse
8 | *
9 | * for: 微信小程序富文本解析
10 | * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
11 | */
12 |
13 | .wxParse{
14 | margin: 0 5px;
15 | font-family: Helvetica,sans-serif;
16 | font-size: 28rpx;
17 | color: #666;
18 | line-height: 1.8;
19 | }
20 | view{
21 | word-break:break-all; overflow:auto;
22 | }
23 | .wxParse-inline{
24 | display: inline;
25 | margin: 0;
26 | padding: 0;
27 | }
28 | /*//标题 */
29 | .wxParse-div{margin: 0;padding: 0;}
30 | .wxParse-h1{ font-size:2em; margin: .67em 0 }
31 | .wxParse-h2{ font-size:1.5em; margin: .75em 0 }
32 | .wxParse-h3{ font-size:1.17em; margin: .83em 0 }
33 | .wxParse-h4{ margin: 1.12em 0}
34 | .wxParse-h5 { font-size:.83em; margin: 1.5em 0 }
35 | .wxParse-h6{ font-size:.75em; margin: 1.67em 0 }
36 |
37 | .wxParse-h1 {
38 | font-size: 18px;
39 | font-weight: 400;
40 | margin-bottom: .9em;
41 | }
42 | .wxParse-h2 {
43 | font-size: 16px;
44 | font-weight: 400;
45 | margin-bottom: .34em;
46 | }
47 | .wxParse-h3 {
48 | font-weight: 400;
49 | font-size: 15px;
50 | margin-bottom: .34em;
51 | }
52 | .wxParse-h4 {
53 | font-weight: 400;
54 | font-size: 14px;
55 | margin-bottom: .24em;
56 | }
57 | .wxParse-h5 {
58 | font-weight: 400;
59 | font-size: 13px;
60 | margin-bottom: .14em;
61 | }
62 | .wxParse-h6 {
63 | font-weight: 400;
64 | font-size: 12px;
65 | margin-bottom: .04em;
66 | }
67 |
68 | .wxParse-h1, .wxParse-h2, .wxParse-h3, .wxParse-h4, .wxParse-h5, .wxParse-h6, .wxParse-b, .wxParse-strong { font-weight: bolder }
69 |
70 | .wxParse-i,.wxParse-cite,.wxParse-em,.wxParse-var,.wxParse-address{font-style:italic}
71 | .wxParse-pre,.wxParse-tt,.wxParse-code,.wxParse-kbd,.wxParse-samp{font-family:monospace}
72 | .wxParse-pre{white-space:pre}
73 | .wxParse-big{font-size:1.17em}
74 | .wxParse-small,.wxParse-sub,.wxParse-sup{font-size:.83em}
75 | .wxParse-sub{vertical-align:sub}
76 | .wxParse-sup{vertical-align:super}
77 | .wxParse-s,.wxParse-strike,.wxParse-del{text-decoration:line-through}
78 | /*wxparse-自定义个性化的css样式*/
79 | /*增加video的css样式*/
80 | .wxParse-strong,.wxParse-s{display: inline}
81 | .wxParse-a{
82 | color: deepskyblue;
83 | word-break:break-all;
84 | overflow:auto;
85 | }
86 |
87 | .wxParse-video{
88 | text-align: center;
89 | margin: 10px 0;
90 | }
91 |
92 | .wxParse-video-video{
93 | width:100%;
94 | }
95 |
96 | .wxParse-img{
97 | /*background-color: #efefef;*/
98 | overflow: hidden;
99 | }
100 |
101 | .wxParse-blockquote {
102 | margin: 0;
103 | padding:10px 0 10px 5px;
104 | font-family:Courier, Calibri,"宋体";
105 | background:#f5f5f5;
106 | border-left: 3px solid #dbdbdb;
107 | }
108 |
109 | .wxParse-code,.wxParse-wxxxcode-style{
110 | display: inline;
111 | background:#f5f5f5;
112 | }
113 | .wxParse-ul{
114 | margin: 20rpx 10rpx;
115 | }
116 |
117 | .wxParse-li,.wxParse-li-inner{
118 | display: flex;
119 | align-items: baseline;
120 | margin: 10rpx 0;
121 | }
122 | .wxParse-li-text{
123 |
124 | align-items: center;
125 | line-height: 20px;
126 | }
127 |
128 | .wxParse-li-circle{
129 | display: inline-flex;
130 | width: 5px;
131 | height: 5px;
132 | background-color: #333;
133 | margin-right: 5px;
134 | }
135 |
136 | .wxParse-li-square{
137 | display: inline-flex;
138 | width: 10rpx;
139 | height: 10rpx;
140 | background-color: #333;
141 | margin-right: 5px;
142 | }
143 | .wxParse-li-ring{
144 | display: inline-flex;
145 | width: 10rpx;
146 | height: 10rpx;
147 | border: 2rpx solid #333;
148 | border-radius: 50%;
149 | background-color: #fff;
150 | margin-right: 5px;
151 | }
152 |
153 | /*.wxParse-table{
154 | width: 100%;
155 | height: 400px;
156 | }
157 | .wxParse-thead,.wxParse-tfoot,.wxParse-tr{
158 | display: flex;
159 | flex-direction: row;
160 | }
161 | .wxParse-th,.wxParse-td{
162 | display: flex;
163 | width: 580px;
164 | overflow: auto;
165 | }*/
166 |
167 | .wxParse-u {
168 | text-decoration: underline;
169 | }
170 | .wxParse-hide{
171 | display: none;
172 | }
173 | .WxEmojiView{
174 | align-items: center;
175 | }
176 | .wxEmoji{
177 | width: 16px;
178 | height:16px;
179 | }
180 | .wxParse-tr{
181 | display: flex;
182 | border-right:1px solid #e0e0e0;
183 | border-bottom:1px solid #e0e0e0;
184 | border-top:1px solid #e0e0e0;
185 | }
186 | .wxParse-th,
187 | .wxParse-td{
188 | flex:1;
189 | padding:5px;
190 | font-size:28rpx;
191 | border-left:1px solid #e0e0e0;
192 | word-break: break-all;
193 | }
194 | .wxParse-td:last{
195 | border-top:1px solid #e0e0e0;
196 | }
197 | .wxParse-th{
198 | background:#f0f0f0;
199 | border-top:1px solid #e0e0e0;
200 | }
201 | .wxParse-del{
202 | display: inline;
203 | }
204 | .wxParse-figure {
205 | overflow: hidden;
206 | }
207 |
--------------------------------------------------------------------------------
39 | 
98 | 
99 |