The parser is based on a node module. But to work within a web application, there is browserified version named 'bundle.js' within the 'js' folder. The node module is contained in 'md_parser'.
npm install md_parser
npm install md_parser -g
md_parser <source> <outputFile>
- The 1st argument (source) is required. If it is a file, the file will be read.
- The 2nd argument is optional. If it's given, it will be handled as an output file. If it's not given, the result will be printed in console.
The parser parses the following elements in this way:
- Bold text
**Bold**
- Italic text
*Italic*
- Striked text
~~Striked~~
- Lists (a sub list needs two spaces)
* List item
- Unsorted lists (circular)
* Item
- Sorted lists (numeric)
1. Item
- Alphabetic Lists lower and upper (lower/upper-alpha)
a. Item
/A. Item
- Roman Lists (upper-roman)
I. Item
- Unsorted lists (circular)
- Tables (Table Syntax of Github Markdown)
- Code Blocks (inline
<code></code>
and blocked<pre><code></code></pre>
)
Please make sure that the lists will all be parsed as <ul>
containing the specific list style as CSS rule.
Why?
Because of support for untypically lists like alphabetic and roman.
const markdown = require('md_parser');
// Returns the following
{
parse: [Function],
rules: [Array]
}
The md_parser
instance returns the method parse
and the array rules
. This array contains the default parsing rules and can be customized. You can see more below.
const markdown = require('md_parser');
var markdownStr = "# Title 1\n## Title 2\n\nParagraph"; // The string containing the markdown context
markdown.parse(markdownStr, {
//rules: [], // Custom parsing rules. Don't use by default
validDocument: true, // Wether the returned string is a valid HTML document with DOCTYPE, head, body etc.
pretty: true // Wether the result is pretty printed
});
The parsing rules are an array with some regular expressions and functions.
The default rules are located in the file default-rules.js
. These rules are sometimes just regular expressions and sometimes more complex functions.
The md_parser
instance contains such an array with the default rules. If you call the parse
method and you don't pass a custom array with rules as option, the rules array of the md_parser
instance will be used.
A rules array contains objects as rules. Every object represents one markdown element.
Have a look at the general structure of a rules array.
// Rules array
[
{...}, // Some other rules
{
name: "name-of-element", // The name of the element.
query: '(.*)', // A regular expression string
replace: '<myReplacement>$1</myReplacement>', // The replacement for the regex
parse: function(str) {
// Special parsing function that returns the parsed string
return str;
}
},
{...} // Some other rules
]
You don't understand it?
For example, let's have a look at the parsing rule for a strong
tag:
{
name: "bold",
query: '\\*{2}([^\\*]*)\\*{2}', // Queries bold text
replace: '<strong>$1</strong>'
}
As you can see, a special parse
function isn't required in this case. In some other cases there is no regular expression but just a special parse
function within the rule object.