node-marked-man-0.2.0/000077500000000000000000000000001302237707600144575ustar00rootroot00000000000000node-marked-man-0.2.0/.gitignore000066400000000000000000000000331302237707600164430ustar00rootroot00000000000000node_modules test/*/*.err node-marked-man-0.2.0/CHANGES.md000066400000000000000000000002531302237707600160510ustar00rootroot000000000000000.1.4 ===== * depends on marked 0.3.2 * use .nf/.fi instead of .EX/.EE to format blockquotes 0.1.6 ===== * ensure tests pass 0.2.0 ===== * add support for gfm table node-marked-man-0.2.0/LICENSE000066400000000000000000000025741302237707600154740ustar00rootroot00000000000000Files:* Copyright: 2013 Jérémy Lal License: MIT Files: lib/marked-man.js Copyright: 2013 Jérémy Lal 2011-2013 Christopher Jeffrey (https://github.com/chjj/) License: MIT Files: test/files/* Copyright: 2013 Jérémy Lal 2009 Ryan Tomayko (http://tomayko.com/about) License: MIT License: MIT Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: . The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. . THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. node-marked-man-0.2.0/Makefile000066400000000000000000000001551302237707600161200ustar00rootroot00000000000000man/marked-man.1: README.md ./bin/marked-man -o $@ $< doc: man/marked-man.1 check: node test/compare.js node-marked-man-0.2.0/README.md000066400000000000000000000044451302237707600157450ustar00rootroot00000000000000[![NPM](https://nodei.co/npm/marked-man.png?downloads=true)](https://nodei.co/npm/marked-man/) marked-man(1) -- markdown to roff ================================= SYNOPSIS -------- ``` marked-man README.md > doc/marked-man.1 ``` See [marked README](https://github.com/chjj/marked) for documentation about how to use marked. Note that `marked-man --format=html` is the same as `marked`. DESCRIPTION ----------- `marked-man` wraps `marked` to extend it with groff output support in order to create Unix manual pages for use with `man`. OPTIONS ------- `marked-man` invokes `marked --gfm --sanitize`, and you can pass additional options through. The `--breaks` option, which retains intra-paragraph line breaks, can be helpful to match default ronn behavior. `marked-man` adds some options to `marked`'s existing options: * `--format ` Sets the output format. Outputs html if different from `roff`. Defaults to `roff`. * `--name ` The name shown in the manpage header, if it isn't given in the ronn header like in this README. Defaults to empty string. * `--section
` The section number shown in the manpage header, if it isn't given in the ronn header like in this README. Defaults to empty string. * `--version ` The version shown in the manpage footer. Defaults to empty string. * `--manual ` The manual-group name shown in the manpage header. Defaults to empty string. * `--date ` The date shown in the manpage header. Defaults to now, must be acceptable to `new Date(string)`. INSTALLATION ------------ From the [npm registry](https://npmjs.com): * locally (`--save`, `--save-dev`, or `--save-optional` add `marked-man` to your `package.json` file as a runtime, development-time, or optional runtime dependency, respectively) npm install marked-man [--save|--save-dev|--save-optional] * globally (puts `marked-man` in your system's path): [sudo] npm install marked-man -g EXAMPLE ------- To view this README as a man page, run something like the following: marked-man --version v0.1.0 --manual 'Man Utilities' README.md > /tmp/mm$$.1 && man /tmp/mm$$.1 SEE ALSO -------- [Ronn](https://github.com/rtomayko/ronn) REPORTING BUGS -------------- See [marked-man repository](https://github.com/kapouer/marked-man). node-marked-man-0.2.0/bin/000077500000000000000000000000001302237707600152275ustar00rootroot00000000000000node-marked-man-0.2.0/bin/marked-man000077500000000000000000000003451302237707600171730ustar00rootroot00000000000000#!/usr/bin/env node require('../'); // force bin/marked to require marked-man var main = require('marked/bin/marked'); main(process.argv.slice(), function(err, code) { if (err) throw err; return process.exit(code || 0); }); node-marked-man-0.2.0/lib/000077500000000000000000000000001302237707600152255ustar00rootroot00000000000000node-marked-man-0.2.0/lib/marked-man.js000066400000000000000000000236611302237707600176070ustar00rootroot00000000000000var marked = require('marked'); var InlineLexer = marked.InlineLexer; var Parser = marked.Parser; InlineLexer.prototype.html_output = InlineLexer.prototype.output; InlineLexer.prototype.html_outputLink = InlineLexer.prototype.outputLink; InlineLexer.prototype.roff_outputLink = function(cap, link) { var text = this.output(cap[1]); var href = resc(link.href); var same = text == href; if (same) text = ''; return text + ' \\fI' + href + '\\fR'; }; InlineLexer.prototype.roff_output = function(src) { var out = '' , link , text , href , cap; while (src) { // escape if (cap = this.rules.escape.exec(src)) { src = src.substring(cap[0].length); out += cap[1]; continue; } // autolink if (cap = this.rules.autolink.exec(src)) { src = src.substring(cap[0].length); if (cap[2] === '@') { text = cap[1][6] === ':' ? cap[1].substring(7) : cap[1]; } else { text = cap[1]; } out += resc(text); continue; } // url (gfm) if (cap = this.rules.url.exec(src)) { src = src.substring(cap[0].length); out += resc(cap[1]); continue; } // tag if (cap = this.rules.tag.exec(src)) { src = src.substring(cap[0].length); out += resc(cap[0]); continue; } // link if (cap = this.rules.link.exec(src)) { src = src.substring(cap[0].length); out += this.outputLink(cap, { href: cap[2], title: cap[3] }); continue; } // reflink, nolink if ((cap = this.rules.reflink.exec(src)) || (cap = this.rules.nolink.exec(src))) { src = src.substring(cap[0].length); link = (cap[2] || cap[1]).replace(/\s+/g, ' '); link = this.links[link.toLowerCase()]; if (!link || !link.href) { out += cap[0][0]; src = cap[0].substring(1) + src; continue; } out += this.outputLink(cap, link); continue; } // strong if (cap = this.rules.strong.exec(src)) { src = src.substring(cap[0].length); out += '\\fB' + this.output(cap[2] || cap[1]) + '\\fR'; continue; } // em if (cap = this.rules.em.exec(src)) { src = src.substring(cap[0].length); out += '\\fI' + this.output(cap[2] || cap[1]) + '\\fR'; continue; } // code if (cap = this.rules.code.exec(src)) { src = src.substring(cap[0].length); out += '\\fB' + resc(cap[2], true) + '\\fP'; continue; } // br if (cap = this.rules.br.exec(src)) { src = src.substring(cap[0].length); out += '\n.br\n'; continue; } // del (gfm) if (cap = this.rules.del.exec(src)) { src = src.substring(cap[0].length); out += "-" + resc(cap[1]) + "-"; continue; } // text if (cap = this.rules.text.exec(src)) { src = src.substring(cap[0].length); out += resc(cap[0]); continue; } if (src) { throw new Error('Infinite loop on byte: ' + src.charCodeAt(0)); } } return out; }; Parser.prototype.parse = function(src) { this.inline = new InlineLexer(src.links, this.options); this.tokens = src.reverse(); if (this.options.format == "roff") { this.tok = this.roff_tok; this.inline.output = this.inline.roff_output; this.inline.outputLink = this.inline.roff_outputLink; var first = this.peek(); if ((first.type != "heading" || first.depth != 1) && this.options.name) this.tokens.push({type:"heading", depth:1}); } else { this.tok = this.html_tok; this.inline.output = this.inline.html_output; this.inline.outputLink = this.inline.html_outputLink; } var out = ''; while (this.next()) { out += this.tok(); } return out; }; Parser.prototype.html_tok = Parser.prototype.tok; Parser.prototype.roff_tok = function() { switch (this.token.type) { case 'space': { return ''; } case 'hr': { return '.HR\n'; } case 'heading': { var macro, text = this.token.text; if (this.token.depth == 1) { macro = 'TH'; text = rparseHeader(text || "", this.options); } else if (this.token.depth == 2) { macro = 'SH'; text = this.inline.output(text); } else { macro = 'SS'; text = this.inline.output(text); } return '.' + macro + ' ' + text + '\n'; } case 'code': { if (this.options.highlight) { var code = this.options.highlight(this.token.text, this.token.lang); if (code != null && code !== this.token.text) { this.token.escaped = true; this.token.text = code; } } if (!this.token.escaped) { this.token.text = resc(this.token.text); } return '.P\n' + '.RS 2\n' + '.nf\n' + this.token.text + '\n.fi' + '\n.RE\n'; } case 'blockquote_start': { var body = ''; while (this.next().type !== 'blockquote_end') { body += this.tok(); } return '.QP\n' + body + '\n.\n'; } case 'list_start': { var body = ''; var order = this.token.ordered ? 1 : null; while (this.next().type !== 'list_end') { if (order) this.token.order = order++; body += this.tok(); } return '.RS 0\n' + body + '\n.RE\n'; } case 'loose_item_start': case 'list_item_start': { var body = ''; var bullet = '\\(bu'; var offset = 2; if (this.token.order) { bullet = this.token.order + '.'; offset = 3; } while (this.next().type !== 'list_item_end') { var tok = this.tok(); if (this.options.ronn && !this.options.breaks) { // replace first line that ends with colons tok = tok.replace(":\n", '\n.br\n'); // replace dot + newline | whitespaces with dot + line break tok = tok.replace(/\.(?:\n|\s\s+)/g, ".\n.br\n"); } body += tok; } return '.IP ' + bullet + ' ' + offset + '\n' + body; } case 'html': { return !this.token.pre && !this.options.pedantic ? this.inline.output(this.token.text) : this.token.text; } case 'paragraph': { return '.P\n' + this.inline.output(this.token.text) + '\n'; } case 'text': { return '' + this.parseText() + '\n'; } /* deal with table format, add by gholk. * use **tbl** macro format table in man page. */ case 'table': { var tblText = [], // troff tbl macro text. rowArray = []; // tmp array store cells in a table row. tblText.push('.TS'); // table start tblText.push('tab(|) expand box;'); /* set `|` as seperator. * * set table border. * * set expand to full screen. without expand, * tbl sometimes mistake terminal width. * but expand is ugly sometimes... * * command need end by `;`. */ var columnNumberRow = ''; for (var i=0; i=', le: '(<=', ne: '(!=', equiv: '(==', plusmn: '(+-' }[ent]; if (gr) return '\\' + gr; else return match; }); } function rparseHeader(str, options) { var match = /([\w_.\[\]~+=@:-]+)(?:\s*)(?:\((\d\w*)\))?(?:\s*-+\s*(.*))?/.exec(str); var name, section, text; if (match) { name = match[1]; section = match[2]; text = match[3]; } if (!name) name = options.name || ""; if (!section) section = options.section || ""; if (!text) { if (name || section) text = ""; else text = str; } if (name && text) text = " - " + text; return quote(resc(name.toUpperCase())) + " " + quote(section) + " " + quote(manDate(options.date)) + " " + quote(options.version) + " " + quote(options.manual) + "\n.SH " + quote("NAME") + "\n\\fB" + name + "\\fR" + resc(text); } function manDate(date) { date = new Date(date); var month = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"][date.getMonth()]; return month + " " + date.getFullYear(); } marked.defaults.format = "roff"; marked.defaults.name = ""; marked.defaults.date = new Date; marked.defaults.section = ""; marked.defaults.version = ""; marked.defaults.manual = ""; marked.defaults.gfm = true; marked.defaults.breaks = false; marked.defaults.sanitize = true; marked.defaults.ronn = false; module.exports = marked; node-marked-man-0.2.0/man/000077500000000000000000000000001302237707600152325ustar00rootroot00000000000000node-marked-man-0.2.0/man/marked-man.1000066400000000000000000000030211302237707600173240ustar00rootroot00000000000000.TH "MARKED\-MAN" "1" "January 2014" "" "" .SH "NAME" \fBmarked-man\fR \- markdown to roff .SH SYNOPSIS .P .RS 2 .EX marked\-man README\.md > doc/marked\-man\.1 .EE .RE .P See marked README \fIhttps://github\.com/chjj/marked\fR for documentation about how to use marked\. .P Note that \fBmarked\-man \-\-format=html\fR is the same as \fBmarked\fR\|\. .SH DESCRIPTION .P \fBmarked\-man\fR wraps \fBmarked\fR to extend it with groff output support\. .SH OPTIONS .P \fBmarked\-man\fR adds some options to \fBmarked\fR existing options: .RS 0 .IP \(bu 2 format Sets the output format\. Outputs html if different from \fBroff\fR\|\. Defaults to \fBroff\fR\|\. .IP \(bu 2 name The name shown in the manpage header, if it isn\'t given in the ronn header like in this README\. Defaults to empty string\. .IP \(bu 2 section The section shown in the manpage header, if it isn\'t given in the ronn header like in this README\. Defaults to empty string\. .IP \(bu 2 version The version shown in the manpage header\. Defaults to empty string\. .IP \(bu 2 manual The MANUAL string shown in the manpage header\. Defaults to empty string\. .IP \(bu 2 date The date shown in the manpage header\. Defaults to now, must be acceptable by new Date(string)\. .RE .P \fBmarked\-man\fR invokes \fBmarked \-\-gfm \-\-sanitize\fR\|\. The \-\-breaks option can be helpful to match default \fBronn\fR behavior\. .SH SEE ALSO .P Ryan Tomayko \fIhttps://github\.com/rtomayko/ronn\fR .SH REPORTING BUGS .P See marked\-man repository \fIhttps://github\.com/kapouer/marked\-man\fR\|\. node-marked-man-0.2.0/package.json000066400000000000000000000011051302237707600167420ustar00rootroot00000000000000{ "name": "marked-man", "version": "0.2.0", "description": "wrapper adding manpage output to 'marked', inspired by 'ronn'", "main": "lib/marked-man.js", "bin": { "marked-man": "./bin/marked-man" }, "man": [ "./man/marked-man.1" ], "scripts": { "test": "node ./test/compare" }, "repository": { "type": "git", "url": "git://github.com/kapouer/marked-man.git" }, "keywords": [ "markdown", "roff", "ronn" ], "author": "Jérémy Lal ", "license": "MIT", "dependencies": { "marked": "^0.3.2" } } node-marked-man-0.2.0/test/000077500000000000000000000000001302237707600154365ustar00rootroot00000000000000node-marked-man-0.2.0/test/compare.js000066400000000000000000000041521302237707600174240ustar00rootroot00000000000000var fs = require('fs'); var marked = require('../'); var Path = require('path'); var exec = require('child_process').exec; // params var ronnDir = Path.join(__dirname, "md"); var manDir = Path.join(__dirname, "man"); var outDir = Path.join(__dirname, "out"); function convert(name, str, cb) { var roff = marked.parse(str, { format: "roff", name: name, date:'1979-01-01', gfm: true, breaks: true }); var manPath = Path.join(manDir, name); var status = writeOrCompare(roff, manPath); if (status < 0) manPath += '.err'; exec('man --warnings -E UTF-8 ' + manPath, {env: { LANG:"C", MAN_KEEP_FORMATTING: '1', MANWIDTH: "80" }}, function(err, stdout, stderr) { if (stderr) console.error(stderr); cb(err, stdout); }); } fs.readdir(ronnDir, function(err, files) { if (err) throw err; var fails = 0, works = 0, news = 0; var launched = 0; files.forEach(function(path) { launched++; check(path, function(err, status) { if (err) console.error(err); launched--; switch (status) { case -1: fails++; break; case 0: works++; break; case 1: news++; break; } if (!launched) { if (fails > 0) console.error("Failed tests: ", fails); if (works > 0) console.log("Succeeded tests: ", works); if (news > 0) console.log("New tests: ", news); if (fails == 0) console.log("All tests passed"); else process.exit(1); } }); }); }); function writeOrCompare(str, path) { var status = 0; try { var expect = fs.readFileSync(path).toString(); if (expect != str) { var errpath = path + '.err'; console.error("Test failure, result written in", errpath); fs.writeFileSync(errpath, str); status = -1; } } catch(e) { fs.writeFileSync(path, str); status = 1; } return status; } function check(filename, cb) { var ronnBuf = fs.readFileSync(Path.join(ronnDir, filename)); var name = Path.basename(filename, Path.extname(filename)); var destPath = Path.join(outDir, name); convert(name, ronnBuf.toString(), function(err, output) { if (err) return cb(err, 0); var status = writeOrCompare(output, destPath); cb(null, status); }); } node-marked-man-0.2.0/test/man/000077500000000000000000000000001302237707600162115ustar00rootroot00000000000000node-marked-man-0.2.0/test/man/blockquotes000066400000000000000000000002251302237707600204660ustar00rootroot00000000000000.TH "T" "1" "January 1979" "" "" .SH "NAME" \fBt\fR \- test .SH test .P .RS 2 .nf A blockquote here\. Continuing on second line\. .fi .RE .P Hello\. node-marked-man-0.2.0/test/man/definition_list_syntax000066400000000000000000000005501302237707600227250ustar00rootroot00000000000000.TH "DEFITION_LIST_SYNTAX" "5" "January 1979" "" "" .SH "NAME" \fBdefition_list_syntax\fR \- hiya .P Definition lists look like unordered lists: .RS 0 .IP \(bu 2 term: .br definition .IP \(bu 2 another one: .br The definition may span .br multiple lines and even .br start .br new paragraphs .IP \(bu 2 \fB\-\-somearg\fP=: .br We can do that too\. .RE node-marked-man-0.2.0/test/man/dots_at_line_start_test000066400000000000000000000003571302237707600230610ustar00rootroot00000000000000.TH "DOTS_AT_LINE_START_TEST" "" "January 1979" "" "" .SH "NAME" \fBdots_at_line_start_test\fR .P There's a weird issue where dots at the beginning of a line .br generate troff warnings due to escaping\. .P \|\.\. let's see what happens\. node-marked-man-0.2.0/test/man/ellipses000066400000000000000000000003301302237707600177500ustar00rootroot00000000000000.TH "ELLIPSES" "7" "January 1979" "" "" .SH "NAME" \fBellipses\fR \- testing ellipses .P Ellipses should be replaced\.\.\. .P \|\.\.\.also, they shouldn't interfere with regular dots at the beginning .br of a line\. node-marked-man-0.2.0/test/man/entity_encoding_test000066400000000000000000000012751302237707600223620ustar00rootroot00000000000000.TH "HELLO" "1" "January 1979" "" "" .SH "NAME" \fBhello\fR \- hello world .P Your output <i>might</i> look like this: .P .RS 2 .nf * Chris * * <b>GitHub</b> * GitHub .fi .RE .P Here's some special entities: .RS 0 .IP \(bu 2 • \[ci] .IP \(bu 2   \~ .IP \(bu 2 © \(co .IP \(bu 2 ” \(rs .IP \(bu 2 — \(em .IP \(bu 2 ® \(rg .IP \(bu 2 § \(sc .IP \(bu 2 ≥ \(>= .IP \(bu 2 ≤ \(<= .IP \(bu 2 ≠ \(!= .IP \(bu 2 ≡ \(== .IP \(bu 2 ± \(+- .RE .P Here's a line that uses non\-breaking spaces to force the .br last\~few\~words\~to\~wrap\~together\. node-marked-man-0.2.0/test/man/graves000066400000000000000000000001771302237707600174300ustar00rootroot00000000000000.TH "TEST" "" "January 1979" "" "" .SH "NAME" \fBtest\fR .SH this title \fBwill render\fP strangely .P This is the body text\. node-marked-man-0.2.0/test/man/links000066400000000000000000000003371302237707600172570ustar00rootroot00000000000000.TH "LINKS" "" "January 1979" "" "" .SH "NAME" \fBlinks\fR .P I get 10 times more traffic from Google \fIhttp://google\.com/\fR than from .br Yahoo \fIhttp://search\.yahoo\.com/\fR or MSN \fIhttp://search\.msn\.com/\fR\|\. node-marked-man-0.2.0/test/man/markdown_syntax000066400000000000000000000722501302237707600213720ustar00rootroot00000000000000.TH "MARKDOWN" "5" "January 1979" "" "" .SH "NAME" \fBmarkdown\fR \- humane markup syntax .SH SYNOPSIS .P .RS 2 .nf # Header 1 # ## Header 2 ## ### Header 3 ### (Hashes on right are optional) #### Header 4 #### ##### Header 5 ##### This is a paragraph, which is text surrounded by whitespace\. Paragraphs can be on one line (or many), and can drone on for hours\. [Reference style links][1] and [inline links](http://example\.com) [1]: http://example\.com "Title is optional" Inline markup like _italics_, **bold**, and `code()`\. ![picture alt](/images/photo\.jpeg "Title is optional") > Blockquotes are like quoted text in email replies >> And, they can be nested code blocks are for preformatted text and must be indented with four spaces * Bullet lists are easy too * You can * even * nest them \- Another one + Another one .fi .RE .SH DESCRIPTION .SS Philosophy .P Markdown is intended to be as easy\-to\-read and easy\-to\-write as is feasible\. .P Readability, however, is emphasized above all else\. A Markdown\-formatted .br document should be publishable as\-is, as plain text, without looking .br like it's been marked up with tags or formatting instructions\. While .br Markdown's syntax has been influenced by several existing text\-to\-HTML .br filters \-\- including Setext \fIhttp://docutils\.sourceforge\.net/mirror/setext\.html\fR, atx \fIhttp://www\.aaronsw\.com/2002/atx/\fR, Textile \fIhttp://textism\.com/tools/textile/\fR, reStructuredText \fIhttp://docutils\.sourceforge\.net/rst\.html\fR, .br Grutatext \fIhttp://www\.triptico\.com/software/grutatxt\.html\fR, and EtText \fIhttp://ettext\.taint\.org/doc/\fR \-\- the single biggest source of .br inspiration for Markdown's syntax is the format of plain text email\. .P To this end, Markdown's syntax is comprised entirely of punctuation .br characters, which punctuation characters have been carefully chosen so .br as to look like what they mean\. E\.g\., asterisks around a word actually .br look like *emphasis*\|\. Markdown lists look like, well, lists\. Even .br blockquotes look like quoted passages of text, assuming you've ever .br used email\. .SS Inline HTML .P Markdown's syntax is intended for one purpose: to be used as a .br format for \fIwriting\fR for the web\. .P Markdown is not a replacement for HTML, or even close to it\. Its .br syntax is very small, corresponding only to a very small subset of .br HTML tags\. The idea is \fInot\fR to create a syntax that makes it easier .br to insert HTML tags\. In my opinion, HTML tags are already easy to .br insert\. The idea for Markdown is to make it easy to read, write, and .br edit prose\. HTML is a \fIpublishing\fR format; Markdown is a \fIwriting\fR .br format\. Thus, Markdown's formatting syntax only addresses issues that .br can be conveyed in plain text\. .P For any markup that is not covered by Markdown's syntax, you simply .br use HTML itself\. There's no need to preface it or delimit it to .br indicate that you're switching from Markdown to HTML; you just use .br the tags\. .P The only restrictions are that block\-level HTML elements \-\- e\.g\. \fB
\fP, .br \fB\fP, \fB
\fP, \fB
\fP, etc\. \-\- must be separated from surrounding
.br
content by blank lines, and the start and end tags of the block should
.br
not be indented with tabs or spaces\. Markdown is smart enough not
.br
to add extra (unwanted) \fB
\fP tags around HTML block\-level tags\.
.P
For example, to add an HTML table to a Markdown article:
.P
.RS 2
.nf
This is a regular paragraph\.
Foo
This is another regular paragraph\. .fi .RE .P Note that Markdown formatting syntax is not processed within block\-level .br HTML tags\. E\.g\., you can't use Markdown\-style \fB*emphasis*\fP inside an .br HTML block\. .P Span\-level HTML tags \-\- e\.g\. \fB\fP, \fB\fP, or \fB\fP \-\- can be .br used anywhere in a Markdown paragraph, list item, or header\. If you .br want, you can even use HTML tags instead of Markdown formatting; e\.g\. if .br you'd prefer to use HTML \fB\fP or \fB\fP tags instead of Markdown's .br link or image syntax, go right ahead\. .P Unlike block\-level HTML tags, Markdown syntax \fIis\fR processed within .br span\-level tags\. .SS Automatic Escaping for Special Characters .P In HTML, there are two characters that demand special treatment: \fB<\fP .br and \fB&\fP\|\. Left angle brackets are used to start tags; ampersands are .br used to denote HTML entities\. If you want to use them as literal .br characters, you must escape them as entities, e\.g\. \fB<\fP, and .br \fB&\fP\|\. .P Ampersands in particular are bedeviling for web writers\. If you want to .br write about 'AT&T', you need to write '\fBAT&T\fP\|'\. You even need to .br escape ampersands within URLs\. Thus, if you want to link to: .P .RS 2 .nf http://images\.google\.com/images?num=30&q=larry+bird .fi .RE .P you need to encode the URL as: .P .RS 2 .nf http://images\.google\.com/images?num=30&q=larry+bird .fi .RE .P in your anchor tag \fBhref\fP attribute\. Needless to say, this is easy to .br forget, and is probably the single most common source of HTML validation .br errors in otherwise well\-marked\-up web sites\. .P Markdown allows you to use these characters naturally, taking care of .br all the necessary escaping for you\. If you use an ampersand as part of .br an HTML entity, it remains unchanged; otherwise it will be translated .br into \fB&\fP\|\. .P So, if you want to include a copyright symbol in your article, you can write: .P .RS 2 .nf \(co .fi .RE .P and Markdown will leave it alone\. But if you write: .P .RS 2 .nf AT&T .fi .RE .P Markdown will translate it to: .P .RS 2 .nf AT&T .fi .RE .P Similarly, because Markdown supports inline HTML \fI#html\fR, if you use .br angle brackets as delimiters for HTML tags, Markdown will treat them as .br such\. But if you write: .P .RS 2 .nf 4 < 5 .fi .RE .P Markdown will translate it to: .P .RS 2 .nf 4 < 5 .fi .RE .P However, inside Markdown code spans and blocks, angle brackets and .br ampersands are \fIalways\fR encoded automatically\. This makes it easy to use .br Markdown to write about HTML code\. (As opposed to raw HTML, which is a .br terrible format for writing about HTML syntax, because every single \fB<\fP .br and \fB&\fP in your example code needs to be escaped\.) .SH BLOCK ELEMENTS .SS Paragraphs and Line Breaks .P A paragraph is simply one or more consecutive lines of text, separated .br by one or more blank lines\. (A blank line is any line that looks like a .br blank line \-\- a line containing nothing but spaces or tabs is considered .br blank\.) Normal paragraphs should not be indented with spaces or tabs\. .P The implication of the "one or more consecutive lines of text" rule is .br that Markdown supports "hard\-wrapped" text paragraphs\. This differs .br significantly from most other text\-to\-HTML formatters (including Movable .br Type's "Convert Line Breaks" option) which translate every line break .br character in a paragraph into a \fB
\fP tag\. .P When you \fIdo\fR want to insert a \fB
\fP break tag using Markdown, you .br end a line with two or more spaces, then type return\. .P Yes, this takes a tad more effort to create a \fB
\fP, but a simplistic .br "every line break is a \fB
\fP" rule wouldn't work for Markdown\. .br Markdown's email\-style blockquoting \fI#blockquote\fR and multi\-paragraph list items \fI#list\fR .br work best \-\- and look better \-\- when you format them with hard breaks\. .SS Headers .P Markdown supports two styles of headers, Setext \fIhttp://docutils\.sourceforge\.net/mirror/setext\.html\fR and atx \fIhttp://www\.aaronsw\.com/2002/atx/\fR\|\. .P Setext\-style headers are "underlined" using equal signs (for first\-level .br headers) and dashes (for second\-level headers)\. For example: .P .RS 2 .nf This is an H1 ============= This is an H2 \-\-\-\-\-\-\-\-\-\-\-\-\- .fi .RE .P Any number of underlining \fB=\fP\|'s or \fB\-\fP\|'s will work\. .P Atx\-style headers use 1\-6 hash characters at the start of the line, .br corresponding to header levels 1\-6\. For example: .P .RS 2 .nf # This is an H1 ## This is an H2 ###### This is an H6 .fi .RE .P Optionally, you may "close" atx\-style headers\. This is purely .br cosmetic \-\- you can use this if you think it looks better\. The .br closing hashes don't even need to match the number of hashes .br used to open the header\. (The number of opening hashes .br determines the header level\.) : .P .RS 2 .nf # This is an H1 # ## This is an H2 ## ### This is an H3 ###### .fi .RE .SS Blockquotes .P Markdown uses email\-style \fB>\fP characters for blockquoting\. If you're .br familiar with quoting passages of text in an email message, then you .br know how to create a blockquote in Markdown\. It looks best if you hard .br wrap the text and put a \fB>\fP before every line: .P .RS 2 .nf > This is a blockquote with two paragraphs\. Lorem ipsum dolor sit amet, > consectetuer adipiscing elit\. Aliquam hendrerit mi posuere lectus\. > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus\. > > Donec sit amet nisl\. Aliquam semper ipsum sit amet velit\. Suspendisse > id sem consectetuer libero luctus adipiscing\. .fi .RE .P Markdown allows you to be lazy and only put the \fB>\fP before the first .br line of a hard\-wrapped paragraph: .P .RS 2 .nf > This is a blockquote with two paragraphs\. Lorem ipsum dolor sit amet, consectetuer adipiscing elit\. Aliquam hendrerit mi posuere lectus\. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus\. > Donec sit amet nisl\. Aliquam semper ipsum sit amet velit\. Suspendisse id sem consectetuer libero luctus adipiscing\. .fi .RE .P Blockquotes can be nested (i\.e\. a blockquote\-in\-a\-blockquote) by .br adding additional levels of \fB>\fP: .P .RS 2 .nf > This is the first level of quoting\. > > > This is nested blockquote\. > > Back to the first level\. .fi .RE .P Blockquotes can contain other Markdown elements, including headers, lists, .br and code blocks: .P .RS 2 .nf > ## This is a header\. > > 1\. This is the first list item\. > 2\. This is the second list item\. > > Here's some example code: > > return shell_exec("echo $input | $markdown_script"); .fi .RE .P Any decent text editor should make email\-style quoting easy\. For .br example, with BBEdit, you can make a selection and choose Increase .br Quote Level from the Text menu\. .SS Lists .P Markdown supports ordered (numbered) and unordered (bulleted) lists\. .P Unordered lists use asterisks, pluses, and hyphens \-\- interchangably .br \-\- as list markers: .P .RS 2 .nf * Red * Green * Blue .fi .RE .P is equivalent to: .P .RS 2 .nf + Red + Green + Blue .fi .RE .P and: .P .RS 2 .nf \- Red \- Green \- Blue .fi .RE .P Ordered lists use numbers followed by periods: .P .RS 2 .nf 1\. Bird 2\. McHale 3\. Parish .fi .RE .P It's important to note that the actual numbers you use to mark the .br list have no effect on the HTML output Markdown produces\. The HTML .br Markdown produces from the above list is: .P .RS 2 .nf
  1. Bird
  2. McHale
  3. Parish
.fi .RE .P If you instead wrote the list in Markdown like this: .P .RS 2 .nf 1\. Bird 1\. McHale 1\. Parish .fi .RE .P or even: .P .RS 2 .nf 3\. Bird 1\. McHale 8\. Parish .fi .RE .P you'd get the exact same HTML output\. The point is, if you want to, .br you can use ordinal numbers in your ordered Markdown lists, so that .br the numbers in your source match the numbers in your published HTML\. .br But if you want to be lazy, you don't have to\. .P If you do use lazy list numbering, however, you should still start the .br list with the number 1\. At some point in the future, Markdown may support .br starting ordered lists at an arbitrary number\. .P List markers typically start at the left margin, but may be indented by .br up to three spaces\. List markers must be followed by one or more spaces .br or a tab\. .P To make lists look nice, you can wrap items with hanging indents: .P .RS 2 .nf * Lorem ipsum dolor sit amet, consectetuer adipiscing elit\. Aliquam hendrerit mi posuere lectus\. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus\. * Donec sit amet nisl\. Aliquam semper ipsum sit amet velit\. Suspendisse id sem consectetuer libero luctus adipiscing\. .fi .RE .P But if you want to be lazy, you don't have to: .P .RS 2 .nf * Lorem ipsum dolor sit amet, consectetuer adipiscing elit\. Aliquam hendrerit mi posuere lectus\. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus\. * Donec sit amet nisl\. Aliquam semper ipsum sit amet velit\. Suspendisse id sem consectetuer libero luctus adipiscing\. .fi .RE .P If list items are separated by blank lines, Markdown will wrap the .br items in \fB

\fP tags in the HTML output\. For example, this input: .P .RS 2 .nf * Bird * Magic .fi .RE .P will turn into: .P .RS 2 .nf

  • Bird
  • Magic
.fi .RE .P But this: .P .RS 2 .nf * Bird * Magic .fi .RE .P will turn into: .P .RS 2 .nf

  • Bird

  • Magic

.fi .RE .P List items may consist of multiple paragraphs\. Each subsequent .br paragraph in a list item must be indented by either 4 spaces .br or one tab: .P .RS 2 .nf 1\. This is a list item with two paragraphs\. Lorem ipsum dolor sit amet, consectetuer adipiscing elit\. Aliquam hendrerit mi posuere lectus\. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus\. Donec sit amet nisl\. Aliquam semper ipsum sit amet velit\. 2\. Suspendisse id sem consectetuer libero luctus adipiscing\. .fi .RE .P It looks nice if you indent every line of the subsequent .br paragraphs, but here again, Markdown will allow you to be .br lazy: .P .RS 2 .nf * This is a list item with two paragraphs\. This is the second paragraph in the list item\. You're only required to indent the first line\. Lorem ipsum dolor sit amet, consectetuer adipiscing elit\. * Another item in the same list\. .fi .RE .P To put a blockquote within a list item, the blockquote's \fB>\fP .br delimiters need to be indented: .P .RS 2 .nf * A list item with a blockquote: > This is a blockquote > inside a list item\. .fi .RE .P To put a code block within a list item, the code block needs .br to be indented \fItwice\fR \-\- 8 spaces or two tabs: .P .RS 2 .nf * A list item with a code block: .fi .RE .P It's worth noting that it's possible to trigger an ordered list by .br accident, by writing something like this: .P .RS 2 .nf 1986\. What a great season\. .fi .RE .P In other words, a \fInumber\-period\-space\fR sequence at the beginning of a .br line\. To avoid this, you can backslash\-escape the period: .P .RS 2 .nf 1986\\\. What a great season\. .fi .RE .SS Code Blocks .P Pre\-formatted code blocks are used for writing about programming or .br markup source code\. Rather than forming normal paragraphs, the lines .br of a code block are interpreted literally\. Markdown wraps a code block .br in both \fB
\fP and \fB\fP tags\.
.P
To produce a code block in Markdown, simply indent every line of the
.br
block by at least 4 spaces or 1 tab\. For example, given this input:
.P
.RS 2
.nf
This is a normal paragraph:

    This is a code block\.
.fi
.RE
.P
Markdown will generate:
.P
.RS 2
.nf

This is a normal paragraph:



This is a code block\.


.fi
.RE
.P
One level of indentation \-\- 4 spaces or 1 tab \-\- is removed from each
.br
line of the code block\. For example, this:
.P
.RS 2
.nf
Here is an example of AppleScript:

    tell application "Foo"
        beep
    end tell
.fi
.RE
.P
will turn into:
.P
.RS 2
.nf

Here is an example of AppleScript:



tell application "Foo"
    beep
end tell


.fi
.RE
.P
A code block continues until it reaches a line that is not indented
.br
(or the end of the article)\.
.P
Within a code block, ampersands (\fB&\fP) and angle brackets (\fB<\fP and \fB>\fP)
.br
are automatically converted into HTML entities\. This makes it very
.br
easy to include example HTML source code using Markdown \-\- just paste
.br
it and indent it, and Markdown will handle the hassle of encoding the
.br
ampersands and angle brackets\. For example, this:
.P
.RS 2
.nf
    

        \(co 2004 Foo Corporation
    

.fi
.RE
.P
will turn into:
.P
.RS 2
.nf

<div class="footer">
    © 2004 Foo Corporation
</div>


.fi
.RE
.P
Regular Markdown syntax is not processed within code blocks\. E\.g\.,
.br
asterisks are just literal asterisks within a code block\. This means
.br
it's also easy to use Markdown to write about Markdown's own syntax\.
.SS Horizontal Rules
.P
You can produce a horizontal rule tag (\fB
\fP) by placing three or
.br
more hyphens, asterisks, or underscores on a line by themselves\. If you
.br
wish, you may use spaces between the hyphens or asterisks\. Each of the
.br
following lines will produce a horizontal rule:
.P
.RS 2
.nf
* * *

***

*****

\- \- \-

\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
.fi
.RE
.SH SPAN ELEMENTS
.SS Links
.P
Markdown supports two style of links: \fIinline\fR and \fIreference\fR\|\.
.P
In both styles, the link text is delimited by [square brackets]\.
.P
To create an inline link, use a set of regular parentheses immediately
.br
after the link text's closing square bracket\. Inside the parentheses,
.br
put the URL where you want the link to point, along with an \fIoptional\fR
.br
title for the link, surrounded in quotes\. For example:
.P
.RS 2
.nf
This is [an example](http://example\.com/ "Title") inline link\.

[This link](http://example\.net/) has no title attribute\.
.fi
.RE
.P
Will produce:
.P
.RS 2
.nf

This is 
an example inline link\.



This link has no
title attribute\.

.fi
.RE
.P
If you're referring to a local resource on the same server, you can
.br
use relative paths:
.P
.RS 2
.nf
See my [About](/about/) page for details\.
.fi
.RE
.P
Reference\-style links use a second set of square brackets, inside
.br
which you place a label of your choosing to identify the link:
.P
.RS 2
.nf
This is [an example][id] reference\-style link\.
.fi
.RE
.P
You can optionally use a space to separate the sets of brackets:
.P
.RS 2
.nf
This is [an example] [id] reference\-style link\.
.fi
.RE
.P
Then, anywhere in the document, you define your link label like this,
.br
on a line by itself:
.P
.RS 2
.nf
[id]: http://example\.com/  "Optional Title Here"
.fi
.RE
.P
That is:
.RS 0
.IP \(bu 2
Square brackets containing the link identifier (optionally
.br
indented from the left margin using up to three spaces);
.IP \(bu 2
followed by a colon;
.IP \(bu 2
followed by one or more spaces (or tabs);
.IP \(bu 2
followed by the URL for the link;
.IP \(bu 2
optionally followed by a title attribute for the link, enclosed
.br
in double or single quotes, or enclosed in parentheses\.

.RE
.P
The following three link definitions are equivalent:
.P
.RS 2
.nf
[foo]: http://example\.com/  "Optional Title Here"
[foo]: http://example\.com/  'Optional Title Here'
[foo]: http://example\.com/  (Optional Title Here)
.fi
.RE
.P
\fBNote:\fR There is a known bug in Markdown\.pl 1\.0\.1 which prevents
.br
single quotes from being used to delimit link titles\.
.P
The link URL may, optionally, be surrounded by angle brackets:
.P
.RS 2
.nf
[id]:   "Optional Title Here"
.fi
.RE
.P
You can put the title attribute on the next line and use extra spaces
.br
or tabs for padding, which tends to look better with longer URLs:
.P
.RS 2
.nf
[id]: http://example\.com/longish/path/to/resource/here
    "Optional Title Here"
.fi
.RE
.P
Link definitions are only used for creating links during Markdown
.br
processing, and are stripped from your document in the HTML output\.
.P
Link definition names may consist of letters, numbers, spaces, and
.br
punctuation \-\- but they are \fInot\fR case sensitive\. E\.g\. these two
.br
links:
.P
.RS 2
.nf
[link text][a]
[link text][A]
.fi
.RE
.P
are equivalent\.
.P
The \fIimplicit link name\fR shortcut allows you to omit the name of the
.br
link, in which case the link text itself is used as the name\.
.br
Just use an empty set of square brackets \-\- e\.g\., to link the word
.br
"Google" to the google\.com web site, you could simply write:
.P
.RS 2
.nf
[Google][]
.fi
.RE
.P
And then define the link:
.P
.RS 2
.nf
[Google]: http://google\.com/
.fi
.RE
.P
Because link names may contain spaces, this shortcut even works for
.br
multiple words in the link text:
.P
.RS 2
.nf
Visit [Daring Fireball][] for more information\.
.fi
.RE
.P
And then define the link:
.P
.RS 2
.nf
[Daring Fireball]: http://daringfireball\.net/
.fi
.RE
.P
Link definitions can be placed anywhere in your Markdown document\. I
.br
tend to put them immediately after each paragraph in which they're
.br
used, but if you want, you can put them all at the end of your
.br
document, sort of like footnotes\.
.P
Here's an example of reference links in action:
.P
.RS 2
.nf
I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3]\.

  [1]: http://google\.com/        "Google"
  [2]: http://search\.yahoo\.com/  "Yahoo Search"
  [3]: http://search\.msn\.com/    "MSN Search"
.fi
.RE
.P
Using the implicit link name shortcut, you could instead write:
.P
.RS 2
.nf
I get 10 times more traffic from [Google][] than from
[Yahoo][] or [MSN][]\.

  [google]: http://google\.com/        "Google"
  [yahoo]:  http://search\.yahoo\.com/  "Yahoo Search"
  [msn]:    http://search\.msn\.com/    "MSN Search"
.fi
.RE
.P
Both of the above examples will produce the following HTML output:
.P
.RS 2
.nf

I get 10 times more traffic from Google than from
Yahoo
or MSN\.

.fi
.RE
.P
For comparison, here is the same paragraph written using
.br
Markdown's inline link style:
.P
.RS 2
.nf
I get 10 times more traffic from [Google](http://google\.com/ "Google")
than from [Yahoo](http://search\.yahoo\.com/ "Yahoo Search") or
[MSN](http://search\.msn\.com/ "MSN Search")\.
.fi
.RE
.P
The point of reference\-style links is not that they're easier to
.br
write\. The point is that with reference\-style links, your document
.br
source is vastly more readable\. Compare the above examples: using
.br
reference\-style links, the paragraph itself is only 81 characters
.br
long; with inline\-style links, it's 176 characters; and as raw HTML,
.br
it's 234 characters\. In the raw HTML, there's more markup than there
.br
is text\.
.P
With Markdown's reference\-style links, a source document much more
.br
closely resembles the final output, as rendered in a browser\. By
.br
allowing you to move the markup\-related metadata out of the paragraph,
.br
you can add links without interrupting the narrative flow of your
.br
prose\.
.SS Emphasis
.P
Markdown treats asterisks (\fB*\fP) and underscores (\fB_\fP) as indicators of
.br
emphasis\. Text wrapped with one \fB*\fP or \fB_\fP will be wrapped with an
.br
HTML \fB\fP tag; double \fB*\fP\|'s or \fB_\fP\|'s will be wrapped with an HTML
.br
\fB\fP tag\. E\.g\., this input:
.P
.RS 2
.nf
*single asterisks*

_single underscores_

**double asterisks**

__double underscores__
.fi
.RE
.P
will produce:
.P
.RS 2
.nf
single asterisks

single underscores

double asterisks

double underscores
.fi
.RE
.P
You can use whichever style you prefer; the lone restriction is that
.br
the same character must be used to open and close an emphasis span\.
.P
Emphasis can be used in the middle of a word:
.P
.RS 2
.nf
un*frigging*believable
.fi
.RE
.P
But if you surround an \fB*\fP or \fB_\fP with spaces, it'll be treated as a
.br
literal asterisk or underscore\.
.P
To produce a literal asterisk or underscore at a position where it
.br
would otherwise be used as an emphasis delimiter, you can backslash
.br
escape it:
.P
.RS 2
.nf
\\*this text is surrounded by literal asterisks\\*
.fi
.RE
.SS Code
.P
To indicate a span of code, wrap it with backtick quotes (\fB` \fP)\.
.br
Unlike a pre\-formatted code block, a code span indicates code within a
.br
normal paragraph\. For example:
.P
.RS 2
.nf
Use the `printf()` function\.
.fi
.RE
.P
will produce:
.P
.RS 2
.nf

Use the printf() function\.

.fi
.RE
.P
To include a literal backtick character within a code span, you can use
.br
multiple backticks as the opening and closing delimiters:
.P
.RS 2
.nf
``There is a literal backtick (`) here\.``
.fi
.RE
.P
which will produce this:
.P
.RS 2
.nf

There is a literal backtick (`) here\.

.fi
.RE
.P
The backtick delimiters surrounding a code span may include spaces \-\-
.br
one after the opening, one before the closing\. This allows you to place
.br
literal backtick characters at the beginning or end of a code span:
.P
.RS 2
.nf
A single backtick in a code span: `` ` ``

A backtick\-delimited string in a code span: `` `foo` ``
.fi
.RE
.P
will produce:
.P
.RS 2
.nf

A single backtick in a code span: `



A backtick\-delimited string in a code span: `foo`

.fi
.RE
.P
With a code span, ampersands and angle brackets are encoded as HTML
.br
entities automatically, which makes it easy to include example HTML
.br
tags\. Markdown will turn this:
.P
.RS 2
.nf
Please don't use any `` tags\.
.fi
.RE
.P
into:
.P
.RS 2
.nf

Please don't use any <blink> tags\.

.fi
.RE
.P
You can write this:
.P
.RS 2
.nf
`—` is the decimal\-encoded equivalent of `\(em`\.
.fi
.RE
.P
to produce:
.P
.RS 2
.nf

— is the decimal\-encoded
equivalent of &mdash;\.

.fi
.RE
.SS Images
.P
Admittedly, it's fairly difficult to devise a "natural" syntax for
.br
placing images into a plain text document format\.
.P
Markdown uses an image syntax that is intended to resemble the syntax
.br
for links, allowing for two styles: \fIinline\fR and \fIreference\fR\|\.
.P
Inline image syntax looks like this:
.P
.RS 2
.nf
![Alt text](/path/to/img\.jpg)

![Alt text](/path/to/img\.jpg "Optional title")
.fi
.RE
.P
That is:
.RS 0
.IP \(bu 2
An exclamation mark: \fB!\fP;
.IP \(bu 2
followed by a set of square brackets, containing the \fBalt\fP
.br
attribute text for the image;
.IP \(bu 2
followed by a set of parentheses, containing the URL or path to
.br
the image, and an optional \fBtitle\fP attribute enclosed in double
.br
or single quotes\.

.RE
.P
Reference\-style image syntax looks like this:
.P
.RS 2
.nf
![Alt text][id]
.fi
.RE
.P
Where "id" is the name of a defined image reference\. Image references
.br
are defined using syntax identical to link references:
.P
.RS 2
.nf
[id]: url/to/image  "Optional title attribute"
.fi
.RE
.P
As of this writing, Markdown has no syntax for specifying the
.br
dimensions of an image; if this is important to you, you can simply
.br
use regular HTML \fB\fP tags\.
.SH MISCELLANEOUS
.SS Automatic Links
.P
Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets\. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:
.P
.RS 2
.nf

.fi
.RE
.P
Markdown will turn this into:
.P
.RS 2
.nf
http://example\.com/
.fi
.RE
.P
Automatic links for email addresses work similarly, except that
.br
Markdown will also perform a bit of randomized decimal and hex
.br
entity\-encoding to help obscure your address from address\-harvesting
.br
spambots\. For example, Markdown will turn this:
.P
.RS 2
.nf

.fi
.RE
.P
into something like this:
.P
.RS 2
.nf
address@exa
mple.com
.fi
.RE
.P
which will render in a browser as a clickable link to "address@example\.com"\.
.P
(This sort of entity\-encoding trick will indeed fool many, if not
.br
most, address\-harvesting bots, but it definitely won't fool all of
.br
them\. It's better than nothing, but an address published in this way
.br
will probably eventually start receiving spam\.)
.SS Backslash Escapes
.P
Markdown allows you to use backslash escapes to generate literal
.br
characters which would otherwise have special meaning in Markdown's
.br
formatting syntax\. For example, if you wanted to surround a word
.br
with literal asterisks (instead of an HTML \fB\fP tag), you can use
.br
backslashes before the asterisks, like this:
.P
.RS 2
.nf
\\*literal asterisks\\*
.fi
.RE
.P
Markdown provides backslash escapes for the following characters:
.P
.RS 2
.nf
\\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
\-   minus sign (hyphen)
\|\.   dot
!   exclamation mark
.fi
.RE
.SH AUTHOR
.P
Markdown was created by John Gruber\.
.P
Manual page by Ryan Tomayko\. It's pretty much a direct copy of the
.br
Markdown Syntax Reference \fIhttp://daringfireball\.net/projects/markdown/syntax\fR,
.br
also by John Gruber\.
.SH SEE ALSO
.P
ronn(5)
.br
http://daringfireball\.net/projects/markdown/
node-marked-man-0.2.0/test/man/nested_list_with_code000066400000000000000000000003641302237707600225010ustar00rootroot00000000000000.TH "A" "1" "January 1979" "" ""
.SH "NAME"
\fBa\fR
.RS 0
.IP \(bu 2
\fBtoggle_status\fP
.RS 0
.IP \(bu 2
Toggle the display of the status bar\.

.RE
.IP \(bu 2
\fBspawn  \fP TODO explain path\-alike expansion

.RE
node-marked-man-0.2.0/test/man/pre_block_with_quotes000066400000000000000000000001441302237707600225260ustar00rootroot00000000000000.TH "T" "1" "January 1979" "" ""
.SH "NAME"
\fBt\fR \- test
.SH test
.P
.RS 2
.nf
[ "$11" ]
.fi
.RE
node-marked-man-0.2.0/test/man/table000066400000000000000000000157101302237707600172270ustar00rootroot00000000000000.TH "TABLE" "7" "January 1979" "" ""
.SH "NAME"
\fBtable\fR \- test data for table format
.P
test table copy and paste form www\. 
.SH LARGE TABLE
.P
https://en\.wikipedia\.org/wiki/Comparison_of_file_systems
.TS
tab(|) expand box;
 l l l l.
T{
File system
T}|T{
Creator
T}|T{
Year of introduction
T}|T{
Original operating system
T}
_
T{
DECtape
T}|T{
DEC
T}|T{
1964
T}|T{
PDP\-6 Monitor
T}
T{
DASD
T}|T{
IBM
T}|T{
1964
T}|T{
OS/360
T}
T{
Level\-D
T}|T{
DEC
T}|T{
1968
T}|T{
TOPS\-10
T}
T{
George 2
T}|T{
ICT (later ICL)
T}|T{
1968
T}|T{
George 2
T}
T{
Version 6 Unix file system (V6FS)
T}|T{
Bell Labs
T}|T{
1972
T}|T{
Version 6 Unix
T}
T{
RT\-11 file system
T}|T{
DEC
T}|T{
1973
T}|T{
RT\-11
T}
T{
Disk Operating System (GEC DOS)
T}|T{
GEC
T}|T{
1973
T}|T{
Core Operating System
T}
T{
CP/M file system
T}|T{
Digital Research (Gary Kildall)
T}|T{
1974
T}|T{
CP/M[1][2]
T}
T{
ODS\-1
T}|T{
DEC
T}|T{
1975
T}|T{
RSX\-11
T}
T{
GEC DOS filing system extended
T}|T{
GEC
T}|T{
1977
T}|T{
OS4000
T}
T{
FAT (8\-bit)
T}|T{
Microsoft (Marc McDonald) for NCR
T}|T{
1977
T}|T{
Microsoft Standalone Disk BASIC\-80 (later Microsoft Standalone Disk BASIC\-86)
T}
T{
DOS 3\.x
T}|T{
Apple Computer
T}|T{
1978
T}|T{
Apple DOS
T}
T{
Pascal
T}|T{
Apple Computer
T}|T{
1978
T}|T{
Apple Pascal
T}
T{
CBM DOS
T}|T{
Commodore
T}|T{
1978
T}|T{
Commodore BASIC
T}
T{
Version 7 Unix file system (V7FS)
T}|T{
Bell Labs
T}|T{
1979
T}|T{
Version 7 Unix
T}
T{
ODS\-2
T}|T{
DEC
T}|T{
1979
T}|T{
OpenVMS
T}
T{
FAT12
T}|T{
Seattle Computer Products (Tim Paterson)
T}|T{
1980
T}|T{
QDOS/86\-DOS (later IBM PC DOS 1\.0)
T}
T{
DFS
T}|T{
Acorn Computers Ltd
T}|T{
1982
T}|T{
Acorn BBC Micro MOS
T}
T{
ADFS
T}|T{
Acorn Computers Ltd
T}|T{
1983
T}|T{
Acorn Electron (later Arthur RISC OS)
T}
T{
FFS
T}|T{
Kirk McKusick
T}|T{
1983
T}|T{
4\.2BSD
T}
T{
ProDOS
T}|T{
Apple Computer
T}|T{
1983
T}|T{
ProDOS 8
T}
T{
FAT16
T}|T{
IBM, Microsoft
T}|T{
1984
T}|T{
PC DOS 3\.0, MS\-DOS 3\.0
T}
T{
MFS
T}|T{
Apple Computer
T}|T{
1984
T}|T{
System 1
T}
T{
Elektronika BK tape format
T}|T{
NPO "Scientific centre" (now Sitronics)
T}|T{
1985
T}|T{
Vilnius Basic, BK monitor program
T}
T{
HFS
T}|T{
Apple Computer
T}|T{
1985
T}|T{
System 2\.1
T}
T{
Amiga OFS[1]
T}|T{
Metacomco for Commodore
T}|T{
1985
T}|T{
Amiga OS
T}
T{
NWFS
T}|T{
Novell
T}|T{
1985
T}|T{
NetWare 286
T}
T{
High Sierra
T}|T{
Ecma International
T}|T{
1986
T}|T{
MSCDEX for MS\-DOS 3\.1/3\.2[3]
T}
T{
FAT16B
T}|T{
Compaq
T}|T{
1987
T}|T{
Compaq MS\-DOS 3\.31
T}
T{
Minix V1 FS
T}|T{
Andrew S\. Tanenbaum
T}|T{
1987
T}|T{
MINIX 1\.0
T}
T{
Amiga FFS
T}|T{
Commodore
T}|T{
1988
T}|T{
Amiga OS 1\.3
T}
T{
ISO 9660:1988
T}|T{
Ecma International, ISO
T}|T{
1988
T}|T{
MS\-DOS, "classic" Mac OS, and AmigaOS
T}
T{
HPFS
T}|T{
IBM & Microsoft
T}|T{
1989
T}|T{
OS/2 1\.2
T}
T{
JFS1
T}|T{
IBM
T}|T{
1990
T}|T{
AIX[a]
T}
T{
VxFS
T}|T{
VERITAS
T}|T{
1991
T}|T{
SVR4\.0
T}
T{
ext
T}|T{
Rémy Card
T}|T{
1992
T}|T{
Linux
T}
T{
AdvFS
T}|T{
DEC
T}|T{
1993[4]
T}|T{
Digital Unix
T}
T{
NTFS
T}|T{
Microsoft (Gary Kimura, Tom Miller)
T}|T{
1993
T}|T{
Windows NT 3\.1
T}
T{
LFS
T}|T{
Margo Seltzer
T}|T{
1993
T}|T{
Berkeley Sprite
T}
T{
ext2
T}|T{
Rémy Card
T}|T{
1993
T}|T{
Linux, Hurd
T}
T{
Xiafs
T}|T{
Q\. Frank Xia
T}|T{
1993
T}|T{
Linux
T}
T{
UFS1
T}|T{
Kirk McKusick
T}|T{
1994
T}|T{
4\.4BSD
T}
T{
XFS
T}|T{
SGI
T}|T{
1994
T}|T{
IRIX, Linux, FreeBSD
T}
T{
HFS
T}|T{
IBM
T}|T{
1994
T}|T{
MVS/ESA (now z/OS)
T}
T{
FAT16X
T}|T{
Microsoft
T}|T{
1995
T}|T{
MS\-DOS 7\.0 / Windows 95
T}
T{
Joliet ("CDFS")
T}|T{
Microsoft
T}|T{
1995
T}|T{
Microsoft Windows, Linux, "classic" Mac OS, and FreeBSD
T}
T{
UDF
T}|T{
ISO/ECMA/OSTA
T}|T{
1995
T}|T{
N/A
T}
T{
FAT32, FAT32X
T}|T{
Microsoft
T}|T{
1996
T}|T{
MS\-DOS 7\.10 / Windows 95 OSR2[b]
T}
T{
QFS
T}|T{
Sun Microsystems
T}|T{
1996
T}|T{
Solaris
T}
T{
GPFS
T}|T{
IBM
T}|T{
1996
T}|T{
AIX, Linux
T}
T{
Be File System
T}|T{
Be Inc\. (D\. Giampaolo, Cyril Meurillon)
T}|T{
1996
T}|T{
BeOS
T}
T{
Minix V2 FS
T}|T{
Andrew S\. Tanenbaum
T}|T{
1997
T}|T{
MINIX 2\.0
T}
T{
HFS Plus
T}|T{
Apple Computer
T}|T{
1998
T}|T{
Mac OS 8\.1
T}
T{
NSS
T}|T{
Novell
T}|T{
1998
T}|T{
NetWare 5
T}
T{
PolyServe File System (PSFS)
T}|T{
PolyServe
T}|T{
1998
T}|T{
Windows, Linux
T}
T{
ODS\-5
T}|T{
DEC
T}|T{
1998
T}|T{
OpenVMS 7\.2
T}
T{
WAFL
T}|T{
NetApp
T}|T{
1998
T}|T{
Data ONTAP
T}
T{
ext3
T}|T{
Dr\. Stephen C\. Tweedie
T}|T{
1999
T}|T{
Linux
T}
T{
ISO 9660:1999
T}|T{
Ecma International, ISO
T}|T{
1999
T}|T{
Microsoft Windows, Linux, "classic" Mac OS, FreeBSD, and AmigaOS
T}
T{
Lustre
T}|T{
Cluster File Systems[5]
T}|T{
2002
T}|T{
Linux
T}
T{
JFS
T}|T{
IBM
T}|T{
1999
T}|T{
OS/2 Warp Server for e\-business
T}
T{
GFS
T}|T{
Sistina (Red Hat)
T}|T{
2000
T}|T{
Linux
T}
T{
ReiserFS
T}|T{
Namesys
T}|T{
2001
T}|T{
Linux
T}
T{
zFS
T}|T{
IBM
T}|T{
2001
T}|T{
z/OS (backported to OS/390)
T}
T{
FATX
T}|T{
Microsoft
T}|T{
2002
T}|T{
Xbox
T}
T{
UFS2
T}|T{
Kirk McKusick
T}|T{
2002
T}|T{
FreeBSD 5\.0
T}
T{
OCFS
T}|T{
Oracle Corporation
T}|T{
2002
T}|T{
Linux
T}
T{
VMFS2
T}|T{
VMware
T}|T{
2002
T}|T{
VMware ESX Server 2\.0
T}
T{
Fossil
T}|T{
Bell Labs
T}|T{
2003
T}|T{
Plan 9 version 4
T}
T{
Google File System
T}|T{
Google
T}|T{
2003
T}|T{
Linux
T}
T{
ZFS
T}|T{
Sun Microsystems
T}|T{
2004
T}|T{
Solaris
T}
T{
Reiser4
T}|T{
Namesys
T}|T{
2004
T}|T{
Linux
T}
T{
Non\-Volatile File System
T}|T{
Palm, Inc\.
T}|T{
2004
T}|T{
Palm OS Garnet
T}
T{
Minix V3 FS
T}|T{
Andrew S\. Tanenbaum
T}|T{
2005
T}|T{
MINIX 3
T}
T{
OCFS2
T}|T{
Oracle Corporation
T}|T{
2005
T}|T{
Linux
T}
T{
NILFS
T}|T{
NTT
T}|T{
2005
T}|T{
Linux
T}
T{
VMFS3
T}|T{
VMware
T}|T{
2005
T}|T{
VMware ESX Server 3\.0
T}
T{
GFS2
T}|T{
Red Hat
T}|T{
2006
T}|T{
Linux
T}
T{
ext4
T}|T{
various
T}|T{
2006
T}|T{
Linux
T}
T{
exFAT
T}|T{
Microsoft
T}|T{
2006
T}|T{
Windows CE 6\.0
T}
T{
Btrfs
T}|T{
Oracle Corporation
T}|T{
2007
T}|T{
Linux
T}
T{
JXFS
T}|T{
Hyperion Entertainment
T}|T{
2008
T}|T{
AmigaOS 4\.1
T}
T{
HAMMER
T}|T{
Matthew Dillon
T}|T{
2008
T}|T{
DragonFly BSD 2\.0
T}
T{
LSFS
T}|T{
StarWind Software
T}|T{
2009
T}|T{
Linux, FreeBSD, Windows
T}
T{
CASL
T}|T{
Nimble Storage
T}|T{
2010
T}|T{
Linux
T}
T{
VMFS5
T}|T{
VMware
T}|T{
2011
T}|T{
vSphere 5\.0+
T}
T{
ReFS
T}|T{
Microsoft
T}|T{
2012
T}|T{
Windows Server 2012
T}
T{
F2FS
T}|T{
Samsung Electronics
T}|T{
2012
T}|T{
Linux
T}
T{
APFS
T}|T{
Apple Computer
T}|T{
2016
T}|T{
macOS
T}
.TE
.SH LONG TEXT
.P
http://www\.troff\.org/faq\.html
.TS
tab(|) expand box;
 l l l.
T{
Person
T}|T{
Work
T}|T{
Quote
T}
_
T{
Sherlock Holmes
T}|T{
The Norwood Builder
T}|T{
You mentioned your name as if I should recognize it, but beyond the obvious facts that you are a bachelor, a solicitor, a freemason, and an asthmatic, I know nothing whatever about you\.
T}
.TE
.SH THING TABLE
.TS
tab(|) expand box;
 l l.
T{
1
T}|T{
2
T}
_
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
T{1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
T{
1
T}|T{
2
T}
.TE
.SH REPORTING BUGS
.P
xxxxx@xxxx\.xxxx\.xxxx\.xx
node-marked-man-0.2.0/test/man/underline_spacing_test000066400000000000000000000005221302237707600226630ustar00rootroot00000000000000.TH "THIS" "" "January 1979" "" ""
.SH "NAME"
\fBThis\fR
.RS 0
.IP \(bu 2
\fB\-S\fP \fItext\fR, \fBsearch\fP \fItext\fR:
.br
 Performs a substring search of formula names for \fItext\fR\|\.
.IP \(bu 2
\fB\-O\fP , \fBother\fP :
.br
 Does something else\.

.RE
.P
Should space text properly\.
.P


node-marked-man-0.2.0/test/md/000077500000000000000000000000001302237707600160365ustar00rootroot00000000000000node-marked-man-0.2.0/test/md/blockquotes.md000066400000000000000000000001401302237707600207060ustar00rootroot00000000000000t(1) - test
===========

## test

    A blockquote here.
    Continuing on second line.

Hello.
node-marked-man-0.2.0/test/md/definition_list_syntax.md000066400000000000000000000004421302237707600231510ustar00rootroot00000000000000defition_list_syntax(5) -- hiya
===============================

Definition lists look like unordered lists:

  * term:
    definition

  * another one:
    The definition may span
    multiple lines and even 
    start 
    new paragraphs

  * `--somearg`=:
    We can do that too.
node-marked-man-0.2.0/test/md/dots_at_line_start_test.md000066400000000000000000000002011302237707600232710ustar00rootroot00000000000000There's a weird issue where dots at the beginning of a line
generate troff warnings due to escaping.

.. let's see what happens.
node-marked-man-0.2.0/test/md/ellipses.md000066400000000000000000000002611302237707600201770ustar00rootroot00000000000000ellipses(7) -- testing ellipses
===============================

Ellipses should be replaced...

...also, they shouldn't interfere with regular dots at the beginning
of a line.
node-marked-man-0.2.0/test/md/entity_encoding_test.md000066400000000000000000000011711302237707600226010ustar00rootroot00000000000000# hello(1) -- hello world

Your output <i>might</i> look like this:

    * Chris
    *
    * <b>GitHub</b>
    * GitHub

Here's some special entities:

  * &bull;       •
  * &nbsp;        
  * &copy;       ©
  * &rdquo;      ”
  * &mdash;      —
  * &reg;        ®
  * &sect;       §
  * &ge;         ≥
  * &le;         ≤
  * &ne;         ≠
  * &equiv;      ≡
  * &plusmn;     ±

Here's a line that uses non-breaking spaces to force the
last few words to wrap together.
node-marked-man-0.2.0/test/md/graves.md000066400000000000000000000001121302237707600176410ustar00rootroot00000000000000test
====

## this title `will render` strangely

This is the body text.

node-marked-man-0.2.0/test/md/links.md000066400000000000000000000003331302237707600174770ustar00rootroot00000000000000I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3].

  [1]: http://google.com/        "Google"
  [2]: http://search.yahoo.com/  "Yahoo Search"
  [3]: http://search.msn.com/    "MSN Search"
node-marked-man-0.2.0/test/md/markdown_syntax.md000066400000000000000000000654221302237707600216210ustar00rootroot00000000000000markdown(5) -- humane markup syntax
===================================

## SYNOPSIS

    # Header 1 #
    ## Header 2 ##
    ### Header 3 ###             (Hashes on right are optional)
    #### Header 4 ####
    ##### Header 5 #####

    This is a paragraph, which is text surrounded by whitespace.
    Paragraphs can be on one line (or many), and can drone on for
    hours.

    [Reference style links][1] and [inline links](http://example.com)
    [1]: http://example.com "Title is optional"

    Inline markup like _italics_,  **bold**, and `code()`.

    ![picture alt](/images/photo.jpeg "Title is optional")

    > Blockquotes are like quoted text in email replies
    >> And, they can be nested

        code blocks are for preformatted
        text and must be indented with four spaces

    * Bullet lists are easy too
      * You can
      * even
      * nest them
    - Another one
    + Another one

## DESCRIPTION

### Philosophy

Markdown is intended to be as easy-to-read and easy-to-write as is feasible.

Readability, however, is emphasized above all else. A Markdown-formatted
document should be publishable as-is, as plain text, without looking
like it's been marked up with tags or formatting instructions. While
Markdown's syntax has been influenced by several existing text-to-HTML
filters -- including [Setext] [1], [atx] [2], [Textile] [3], [reStructuredText] [4],
[Grutatext] [5], and [EtText] [6] -- the single biggest source of
inspiration for Markdown's syntax is the format of plain text email.

  [1]: http://docutils.sourceforge.net/mirror/setext.html
  [2]: http://www.aaronsw.com/2002/atx/
  [3]: http://textism.com/tools/textile/
  [4]: http://docutils.sourceforge.net/rst.html
  [5]: http://www.triptico.com/software/grutatxt.html
  [6]: http://ettext.taint.org/doc/

To this end, Markdown's syntax is comprised entirely of punctuation
characters, which punctuation characters have been carefully chosen so
as to look like what they mean. E.g., asterisks around a word actually
look like \*emphasis\*. Markdown lists look like, well, lists. Even
blockquotes look like quoted passages of text, assuming you've ever
used email.

### Inline HTML

Markdown's syntax is intended for one purpose: to be used as a
format for *writing* for the web.

Markdown is not a replacement for HTML, or even close to it. Its
syntax is very small, corresponding only to a very small subset of
HTML tags. The idea is *not* to create a syntax that makes it easier
to insert HTML tags. In my opinion, HTML tags are already easy to
insert. The idea for Markdown is to make it easy to read, write, and
edit prose. HTML is a *publishing* format; Markdown is a *writing*
format. Thus, Markdown's formatting syntax only addresses issues that
can be conveyed in plain text.

For any markup that is not covered by Markdown's syntax, you simply
use HTML itself. There's no need to preface it or delimit it to
indicate that you're switching from Markdown to HTML; you just use
the tags.

The only restrictions are that block-level HTML elements -- e.g. `
`,
``, `
`, `
`, etc. -- must be separated from surrounding
content by blank lines, and the start and end tags of the block should
not be indented with tabs or spaces. Markdown is smart enough not
to add extra (unwanted) `
` tags around HTML block-level tags.

For example, to add an HTML table to a Markdown article:

    This is a regular paragraph.

    

        

            Foo
        

    


    This is another regular paragraph.

Note that Markdown formatting syntax is not processed within block-level
HTML tags. E.g., you can't use Markdown-style `*emphasis*` inside an
HTML block.

Span-level HTML tags -- e.g. ``, ``, or `` -- can be
used anywhere in a Markdown paragraph, list item, or header. If you
want, you can even use HTML tags instead of Markdown formatting; e.g. if
you'd prefer to use HTML `` or `` tags instead of Markdown's
link or image syntax, go right ahead.

Unlike block-level HTML tags, Markdown syntax *is* processed within
span-level tags.

### Automatic Escaping for Special Characters

In HTML, there are two characters that demand special treatment: `<`
and `&`. Left angle brackets are used to start tags; ampersands are
used to denote HTML entities. If you want to use them as literal
characters, you must escape them as entities, e.g. `<`, and
`&`.

Ampersands in particular are bedeviling for web writers. If you want to
write about 'AT&T', you need to write '`AT&T`'. You even need to
escape ampersands within URLs. Thus, if you want to link to:

    http://images.google.com/images?num=30&q=larry+bird

you need to encode the URL as:

    http://images.google.com/images?num=30&q=larry+bird

in your anchor tag `href` attribute. Needless to say, this is easy to
forget, and is probably the single most common source of HTML validation
errors in otherwise well-marked-up web sites.

Markdown allows you to use these characters naturally, taking care of
all the necessary escaping for you. If you use an ampersand as part of
an HTML entity, it remains unchanged; otherwise it will be translated
into `&`.

So, if you want to include a copyright symbol in your article, you can write:

    ©

and Markdown will leave it alone. But if you write:

    AT&T

Markdown will translate it to:

    AT&T

Similarly, because Markdown supports [inline HTML](#html), if you use
angle brackets as delimiters for HTML tags, Markdown will treat them as
such. But if you write:

    4 < 5

Markdown will translate it to:

    4 < 5

However, inside Markdown code spans and blocks, angle brackets and
ampersands are *always* encoded automatically. This makes it easy to use
Markdown to write about HTML code. (As opposed to raw HTML, which is a
terrible format for writing about HTML syntax, because every single `<`
and `&` in your example code needs to be escaped.)

## BLOCK ELEMENTS

### Paragraphs and Line Breaks

A paragraph is simply one or more consecutive lines of text, separated
by one or more blank lines. (A blank line is any line that looks like a
blank line -- a line containing nothing but spaces or tabs is considered
blank.) Normal paragraphs should not be indented with spaces or tabs.

The implication of the "one or more consecutive lines of text" rule is
that Markdown supports "hard-wrapped" text paragraphs. This differs
significantly from most other text-to-HTML formatters (including Movable
Type's "Convert Line Breaks" option) which translate every line break
character in a paragraph into a `
` tag.

When you *do* want to insert a `
` break tag using Markdown, you
end a line with two or more spaces, then type return.

Yes, this takes a tad more effort to create a `
`, but a simplistic
"every line break is a `
`" rule wouldn't work for Markdown.
Markdown's email-style [blockquoting][bq] and multi-paragraph [list items][l]
work best -- and look better -- when you format them with hard breaks.

  [bq]: #blockquote
  [l]:  #list

### Headers

Markdown supports two styles of headers, [Setext] [1] and [atx] [2].

Setext-style headers are "underlined" using equal signs (for first-level
headers) and dashes (for second-level headers). For example:

    This is an H1
    =============

    This is an H2
    -------------

Any number of underlining `=`'s or `-`'s will work.

Atx-style headers use 1-6 hash characters at the start of the line,
corresponding to header levels 1-6. For example:

    # This is an H1

    ## This is an H2

    ###### This is an H6

Optionally, you may "close" atx-style headers. This is purely
cosmetic -- you can use this if you think it looks better. The
closing hashes don't even need to match the number of hashes
used to open the header. (The number of opening hashes
determines the header level.) :

    # This is an H1 #

    ## This is an H2 ##

    ### This is an H3 ######

### Blockquotes

Markdown uses email-style `>` characters for blockquoting. If you're
familiar with quoting passages of text in an email message, then you
know how to create a blockquote in Markdown. It looks best if you hard
wrap the text and put a `>` before every line:

    > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
    > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
    > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
    >
    > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
    > id sem consectetuer libero luctus adipiscing.

Markdown allows you to be lazy and only put the `>` before the first
line of a hard-wrapped paragraph:

    > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
    consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
    Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

    > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
    id sem consectetuer libero luctus adipiscing.

Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by
adding additional levels of `>`:

    > This is the first level of quoting.
    >
    > > This is nested blockquote.
    >
    > Back to the first level.

Blockquotes can contain other Markdown elements, including headers, lists,
and code blocks:

    > ## This is a header.
    >
    > 1.   This is the first list item.
    > 2.   This is the second list item.
    >
    > Here's some example code:
    >
    >     return shell_exec("echo $input | $markdown_script");

Any decent text editor should make email-style quoting easy. For
example, with BBEdit, you can make a selection and choose Increase
Quote Level from the Text menu.

### Lists

Markdown supports ordered (numbered) and unordered (bulleted) lists.

Unordered lists use asterisks, pluses, and hyphens -- interchangably
-- as list markers:

    *   Red
    *   Green
    *   Blue

is equivalent to:

    +   Red
    +   Green
    +   Blue

and:

    -   Red
    -   Green
    -   Blue

Ordered lists use numbers followed by periods:

    1.  Bird
    2.  McHale
    3.  Parish

It's important to note that the actual numbers you use to mark the
list have no effect on the HTML output Markdown produces. The HTML
Markdown produces from the above list is:

    
    
    
  1. Bird
    2. 
    
  2. McHale
    3. 
    
  3. Parish
    4. 
    


If you instead wrote the list in Markdown like this:

    1.  Bird
    1.  McHale
    1.  Parish

or even:

    3. Bird
    1. McHale
    8. Parish

you'd get the exact same HTML output. The point is, if you want to,
you can use ordinal numbers in your ordered Markdown lists, so that
the numbers in your source match the numbers in your published HTML.
But if you want to be lazy, you don't have to.

If you do use lazy list numbering, however, you should still start the
list with the number 1. At some point in the future, Markdown may support
starting ordered lists at an arbitrary number.

List markers typically start at the left margin, but may be indented by
up to three spaces. List markers must be followed by one or more spaces
or a tab.

To make lists look nice, you can wrap items with hanging indents:

    *   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
        Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
        viverra nec, fringilla in, laoreet vitae, risus.
    *   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
        Suspendisse id sem consectetuer libero luctus adipiscing.

But if you want to be lazy, you don't have to:

    *   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
    viverra nec, fringilla in, laoreet vitae, risus.
    *   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
    Suspendisse id sem consectetuer libero luctus adipiscing.

If list items are separated by blank lines, Markdown will wrap the
items in `
` tags in the HTML output. For example, this input:

    *   Bird
    *   Magic

will turn into:

    
    
    
  • Bird
    • 
    
  • Magic
    • 
    


But this:

    *   Bird

    *   Magic

will turn into:

    
    
    
  • Bird
    • 
    
  • Magic
    • 
    


List items may consist of multiple paragraphs. Each subsequent
paragraph in a list item must be indented by either 4 spaces
or one tab:

    1.  This is a list item with two paragraphs. Lorem ipsum dolor
        sit amet, consectetuer adipiscing elit. Aliquam hendrerit
        mi posuere lectus.

        Vestibulum enim wisi, viverra nec, fringilla in, laoreet
        vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
        sit amet velit.

    2.  Suspendisse id sem consectetuer libero luctus adipiscing.

It looks nice if you indent every line of the subsequent
paragraphs, but here again, Markdown will allow you to be
lazy:

    *   This is a list item with two paragraphs.

        This is the second paragraph in the list item. You're
    only required to indent the first line. Lorem ipsum dolor
    sit amet, consectetuer adipiscing elit.

    *   Another item in the same list.

To put a blockquote within a list item, the blockquote's `>`
delimiters need to be indented:

    *   A list item with a blockquote:

        > This is a blockquote
        > inside a list item.

To put a code block within a list item, the code block needs
to be indented *twice* -- 8 spaces or two tabs:

    *   A list item with a code block:

            


It's worth noting that it's possible to trigger an ordered list by
accident, by writing something like this:

    1986. What a great season.

In other words, a *number-period-space* sequence at the beginning of a
line. To avoid this, you can backslash-escape the period:

    1986\. What a great season.

### Code Blocks

Pre-formatted code blocks are used for writing about programming or
markup source code. Rather than forming normal paragraphs, the lines
of a code block are interpreted literally. Markdown wraps a code block
in both `
` and `` tags.

To produce a code block in Markdown, simply indent every line of the
block by at least 4 spaces or 1 tab. For example, given this input:

    This is a normal paragraph:

        This is a code block.

Markdown will generate:

    
This is a normal paragraph:


    
This is a code block.
    


One level of indentation -- 4 spaces or 1 tab -- is removed from each
line of the code block. For example, this:

    Here is an example of AppleScript:

        tell application "Foo"
            beep
        end tell

will turn into:

    
Here is an example of AppleScript:


    
tell application "Foo"
        beep
    end tell
    


A code block continues until it reaches a line that is not indented
(or the end of the article).

Within a code block, ampersands (`&`) and angle brackets (`<` and `>`)
are automatically converted into HTML entities. This makes it very
easy to include example HTML source code using Markdown -- just paste
it and indent it, and Markdown will handle the hassle of encoding the
ampersands and angle brackets. For example, this:

        

            © 2004 Foo Corporation
        


will turn into:

    
<div class="footer">
        &copy; 2004 Foo Corporation
    </div>
    


Regular Markdown syntax is not processed within code blocks. E.g.,
asterisks are just literal asterisks within a code block. This means
it's also easy to use Markdown to write about Markdown's own syntax.



### Horizontal Rules

You can produce a horizontal rule tag (`
`) by placing three or
more hyphens, asterisks, or underscores on a line by themselves. If you
wish, you may use spaces between the hyphens or asterisks. Each of the
following lines will produce a horizontal rule:

    * * *

    ***

    *****

    - - -

    ---------------------------------------


## SPAN ELEMENTS

### Links

Markdown supports two style of links: *inline* and *reference*.

In both styles, the link text is delimited by [square brackets].

To create an inline link, use a set of regular parentheses immediately
after the link text's closing square bracket. Inside the parentheses,
put the URL where you want the link to point, along with an *optional*
title for the link, surrounded in quotes. For example:

    This is [an example](http://example.com/ "Title") inline link.

    [This link](http://example.net/) has no title attribute.

Will produce:

    
This is 
    an example inline link.


    
This link has no
    title attribute.


If you're referring to a local resource on the same server, you can
use relative paths:

    See my [About](/about/) page for details.

Reference-style links use a second set of square brackets, inside
which you place a label of your choosing to identify the link:

    This is [an example][id] reference-style link.

You can optionally use a space to separate the sets of brackets:

    This is [an example] [id] reference-style link.

Then, anywhere in the document, you define your link label like this,
on a line by itself:

    [id]: http://example.com/  "Optional Title Here"

That is:

*   Square brackets containing the link identifier (optionally
    indented from the left margin using up to three spaces);
*   followed by a colon;
*   followed by one or more spaces (or tabs);
*   followed by the URL for the link;
*   optionally followed by a title attribute for the link, enclosed
    in double or single quotes, or enclosed in parentheses.

The following three link definitions are equivalent:

    [foo]: http://example.com/  "Optional Title Here"
    [foo]: http://example.com/  'Optional Title Here'
    [foo]: http://example.com/  (Optional Title Here)

**Note:** There is a known bug in Markdown.pl 1.0.1 which prevents
single quotes from being used to delimit link titles.

The link URL may, optionally, be surrounded by angle brackets:

    [id]:   "Optional Title Here"

You can put the title attribute on the next line and use extra spaces
or tabs for padding, which tends to look better with longer URLs:

    [id]: http://example.com/longish/path/to/resource/here
        "Optional Title Here"

Link definitions are only used for creating links during Markdown
processing, and are stripped from your document in the HTML output.

Link definition names may consist of letters, numbers, spaces, and
punctuation -- but they are *not* case sensitive. E.g. these two
links:

    [link text][a]
    [link text][A]

are equivalent.

The *implicit link name* shortcut allows you to omit the name of the
link, in which case the link text itself is used as the name.
Just use an empty set of square brackets -- e.g., to link the word
"Google" to the google.com web site, you could simply write:

    [Google][]

And then define the link:

    [Google]: http://google.com/

Because link names may contain spaces, this shortcut even works for
multiple words in the link text:

    Visit [Daring Fireball][] for more information.

And then define the link:

    [Daring Fireball]: http://daringfireball.net/

Link definitions can be placed anywhere in your Markdown document. I
tend to put them immediately after each paragraph in which they're
used, but if you want, you can put them all at the end of your
document, sort of like footnotes.

Here's an example of reference links in action:

    I get 10 times more traffic from [Google] [1] than from
    [Yahoo] [2] or [MSN] [3].

      [1]: http://google.com/        "Google"
      [2]: http://search.yahoo.com/  "Yahoo Search"
      [3]: http://search.msn.com/    "MSN Search"

Using the implicit link name shortcut, you could instead write:

    I get 10 times more traffic from [Google][] than from
    [Yahoo][] or [MSN][].

      [google]: http://google.com/        "Google"
      [yahoo]:  http://search.yahoo.com/  "Yahoo Search"
      [msn]:    http://search.msn.com/    "MSN Search"

Both of the above examples will produce the following HTML output:

    
I get 10 times more traffic from Google than from
    Yahoo
    or MSN.


For comparison, here is the same paragraph written using
Markdown's inline link style:

    I get 10 times more traffic from [Google](http://google.com/ "Google")
    than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
    [MSN](http://search.msn.com/ "MSN Search").

The point of reference-style links is not that they're easier to
write. The point is that with reference-style links, your document
source is vastly more readable. Compare the above examples: using
reference-style links, the paragraph itself is only 81 characters
long; with inline-style links, it's 176 characters; and as raw HTML,
it's 234 characters. In the raw HTML, there's more markup than there
is text.

With Markdown's reference-style links, a source document much more
closely resembles the final output, as rendered in a browser. By
allowing you to move the markup-related metadata out of the paragraph,
you can add links without interrupting the narrative flow of your
prose.

### Emphasis

Markdown treats asterisks (`*`) and underscores (`_`) as indicators of
emphasis. Text wrapped with one `*` or `_` will be wrapped with an
HTML `` tag; double `*`'s or `_`'s will be wrapped with an HTML
`` tag. E.g., this input:

    *single asterisks*

    _single underscores_

    **double asterisks**

    __double underscores__

will produce:

    single asterisks

    single underscores

    double asterisks

    double underscores

You can use whichever style you prefer; the lone restriction is that
the same character must be used to open and close an emphasis span.

Emphasis can be used in the middle of a word:

    un*frigging*believable

But if you surround an `*` or `_` with spaces, it'll be treated as a
literal asterisk or underscore.

To produce a literal asterisk or underscore at a position where it
would otherwise be used as an emphasis delimiter, you can backslash
escape it:

    \*this text is surrounded by literal asterisks\*


### Code

To indicate a span of code, wrap it with backtick quotes (`` ` ``).
Unlike a pre-formatted code block, a code span indicates code within a
normal paragraph. For example:

    Use the `printf()` function.

will produce:

    
Use the printf() function.


To include a literal backtick character within a code span, you can use
multiple backticks as the opening and closing delimiters:

    ``There is a literal backtick (`) here.``

which will produce this:

    
There is a literal backtick (`) here.


The backtick delimiters surrounding a code span may include spaces --
one after the opening, one before the closing. This allows you to place
literal backtick characters at the beginning or end of a code span:

    A single backtick in a code span: `` ` ``

    A backtick-delimited string in a code span: `` `foo` ``

will produce:

    
A single backtick in a code span: `


    
A backtick-delimited string in a code span: `foo`


With a code span, ampersands and angle brackets are encoded as HTML
entities automatically, which makes it easy to include example HTML
tags. Markdown will turn this:

    Please don't use any `` tags.

into:

    
Please don't use any <blink> tags.


You can write this:

    `—` is the decimal-encoded equivalent of `—`.

to produce:

    
&#8212; is the decimal-encoded
    equivalent of &mdash;.



### Images

Admittedly, it's fairly difficult to devise a "natural" syntax for
placing images into a plain text document format.

Markdown uses an image syntax that is intended to resemble the syntax
for links, allowing for two styles: *inline* and *reference*.

Inline image syntax looks like this:

    ![Alt text](/path/to/img.jpg)

    ![Alt text](/path/to/img.jpg "Optional title")

That is:

*   An exclamation mark: `!`;
*   followed by a set of square brackets, containing the `alt`
    attribute text for the image;
*   followed by a set of parentheses, containing the URL or path to
    the image, and an optional `title` attribute enclosed in double
    or single quotes.

Reference-style image syntax looks like this:

    ![Alt text][id]

Where "id" is the name of a defined image reference. Image references
are defined using syntax identical to link references:

    [id]: url/to/image  "Optional title attribute"

As of this writing, Markdown has no syntax for specifying the
dimensions of an image; if this is important to you, you can simply
use regular HTML `` tags.


## MISCELLANEOUS

### Automatic Links

Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:

    

Markdown will turn this into:

    http://example.com/

Automatic links for email addresses work similarly, except that
Markdown will also perform a bit of randomized decimal and hex
entity-encoding to help obscure your address from address-harvesting
spambots. For example, Markdown will turn this:

    

into something like this:

    address@exa
    mple.com

which will render in a browser as a clickable link to "address@example.com".

(This sort of entity-encoding trick will indeed fool many, if not
most, address-harvesting bots, but it definitely won't fool all of
them. It's better than nothing, but an address published in this way
will probably eventually start receiving spam.)


### Backslash Escapes

Markdown allows you to use backslash escapes to generate literal
characters which would otherwise have special meaning in Markdown's
formatting syntax. For example, if you wanted to surround a word
with literal asterisks (instead of an HTML `` tag), you can use
backslashes before the asterisks, like this:

    \*literal asterisks\*

Markdown provides backslash escapes for the following characters:

    \   backslash
    `   backtick
    *   asterisk
    _   underscore
    {}  curly braces
    []  square brackets
    ()  parentheses
    #   hash mark
    +   plus sign
    -   minus sign (hyphen)
    .   dot
    !   exclamation mark

## AUTHOR

Markdown was created by John Gruber.

Manual page by Ryan Tomayko. It's pretty much a direct copy of the
[Markdown Syntax Reference](http://daringfireball.net/projects/markdown/syntax),
also by John Gruber.

## SEE ALSO

ronn(5)  

node-marked-man-0.2.0/test/md/nested_list_with_code.md000066400000000000000000000002221302237707600227160ustar00rootroot00000000000000a(1)
====

* `toggle_status`
  - Toggle the display of the status bar.
* `spawn  ` TODO explain path-alike expansion
node-marked-man-0.2.0/test/md/pre_block_with_quotes.md000066400000000000000000000000601302237707600227470ustar00rootroot00000000000000t(1) - test
===========

## test

    [ "$11" ]
node-marked-man-0.2.0/test/md/table.md000066400000000000000000000114051302237707600174500ustar00rootroot00000000000000table(7) -- test data for table format
======================================

test table copy and paste form www. 


LARGE TABLE
-----------



File system |Creator |Year of introduction |Original operating system
------------|--------|---------------------|---------------
DECtape |DEC |1964 |PDP-6 Monitor
DASD |IBM |1964 |OS/360
Level-D |DEC |1968 |TOPS-10
George 2 |ICT (later ICL) |1968 |George 2
Version 6 Unix file system (V6FS) |Bell Labs |1972 |Version 6 Unix
RT-11 file system |DEC |1973 |RT-11
Disk Operating System (GEC DOS) |GEC |1973 |Core Operating System
CP/M file system |Digital Research (Gary Kildall) |1974 |CP/M[1][2]
ODS-1 |DEC |1975 |RSX-11
GEC DOS filing system extended |GEC |1977 |OS4000
FAT (8-bit) |Microsoft (Marc McDonald) for NCR |1977 |Microsoft Standalone Disk BASIC-80 (later Microsoft Standalone Disk BASIC-86)
DOS 3.x |Apple Computer |1978 |Apple DOS
Pascal |Apple Computer |1978 |Apple Pascal
CBM DOS |Commodore |1978 |Commodore BASIC
Version 7 Unix file system (V7FS) |Bell Labs |1979 |Version 7 Unix
ODS-2 |DEC |1979 |OpenVMS
FAT12 |Seattle Computer Products (Tim Paterson) |1980 |QDOS/86-DOS (later IBM PC DOS 1.0)
DFS |Acorn Computers Ltd |1982 |Acorn BBC Micro MOS
ADFS |Acorn Computers Ltd |1983 |Acorn Electron (later Arthur RISC OS)
FFS |Kirk McKusick |1983 |4.2BSD
ProDOS |Apple Computer |1983 |ProDOS 8
FAT16 |IBM, Microsoft |1984 |PC DOS 3.0, MS-DOS 3.0
MFS |Apple Computer |1984 |System 1
Elektronika BK tape format |NPO "Scientific centre" (now Sitronics) |1985 |Vilnius Basic, BK monitor program
HFS |Apple Computer |1985 |System 2.1
Amiga OFS[1] |Metacomco for Commodore |1985 |Amiga OS
NWFS |Novell |1985 |NetWare 286
High Sierra |Ecma International |1986 |MSCDEX for MS-DOS 3.1/3.2[3]
FAT16B |Compaq |1987 |Compaq MS-DOS 3.31
Minix V1 FS |Andrew S. Tanenbaum |1987 |MINIX 1.0
Amiga FFS |Commodore |1988 |Amiga OS 1.3
ISO 9660:1988 |Ecma International, ISO |1988 |MS-DOS, "classic" Mac OS, and AmigaOS
HPFS |IBM & Microsoft |1989 |OS/2 1.2
JFS1 |IBM |1990 |AIX[a]
VxFS |VERITAS |1991 |SVR4.0
ext |Rémy Card |1992 |Linux
AdvFS |DEC |1993[4] |Digital Unix
NTFS |Microsoft (Gary Kimura, Tom Miller) |1993 |Windows NT 3.1
LFS |Margo Seltzer |1993 |Berkeley Sprite
ext2 |Rémy Card |1993 |Linux, Hurd
Xiafs |Q. Frank Xia |1993 |Linux
UFS1 |Kirk McKusick |1994 |4.4BSD
XFS |SGI |1994 |IRIX, Linux, FreeBSD
HFS |IBM |1994 |MVS/ESA (now z/OS)
FAT16X |Microsoft |1995 |MS-DOS 7.0 / Windows 95
Joliet ("CDFS") |Microsoft |1995 |Microsoft Windows, Linux, "classic" Mac OS, and FreeBSD
UDF |ISO/ECMA/OSTA |1995 |N/A
FAT32, FAT32X |Microsoft |1996 |MS-DOS 7.10 / Windows 95 OSR2[b]
QFS |Sun Microsystems |1996 |Solaris
GPFS |IBM |1996 |AIX, Linux
Be File System |Be Inc. (D. Giampaolo, Cyril Meurillon) |1996 |BeOS
Minix V2 FS |Andrew S. Tanenbaum |1997 |MINIX 2.0
HFS Plus |Apple Computer |1998 |Mac OS 8.1
NSS |Novell |1998 |NetWare 5
PolyServe File System (PSFS) |PolyServe |1998 |Windows, Linux
ODS-5 |DEC |1998 |OpenVMS 7.2
WAFL |NetApp |1998 |Data ONTAP
ext3 |Dr. Stephen C. Tweedie |1999 |Linux
ISO 9660:1999 |Ecma International, ISO |1999 |Microsoft Windows, Linux, "classic" Mac OS, FreeBSD, and AmigaOS
Lustre |Cluster File Systems[5] |2002 |Linux
JFS |IBM |1999 |OS/2 Warp Server for e-business
GFS |Sistina (Red Hat) |2000 |Linux
ReiserFS |Namesys |2001 |Linux
zFS |IBM |2001 |z/OS (backported to OS/390)
FATX |Microsoft |2002 |Xbox
UFS2 |Kirk McKusick |2002 |FreeBSD 5.0
OCFS |Oracle Corporation |2002 |Linux
VMFS2 |VMware |2002 |VMware ESX Server 2.0
Fossil |Bell Labs |2003 |Plan 9 version 4
Google File System |Google |2003 |Linux
ZFS |Sun Microsystems |2004 |Solaris
Reiser4 |Namesys |2004 |Linux
Non-Volatile File System |Palm, Inc. |2004 |Palm OS Garnet
Minix V3 FS |Andrew S. Tanenbaum |2005 |MINIX 3
OCFS2 |Oracle Corporation |2005 |Linux
NILFS |NTT |2005 |Linux
VMFS3 |VMware |2005 |VMware ESX Server 3.0
GFS2 |Red Hat |2006 |Linux
ext4 |various |2006 |Linux
exFAT |Microsoft |2006 |Windows CE 6.0
Btrfs |Oracle Corporation |2007 |Linux
JXFS |Hyperion Entertainment |2008 |AmigaOS 4.1
HAMMER |Matthew Dillon |2008 |DragonFly BSD 2.0
LSFS |StarWind Software |2009 |Linux, FreeBSD, Windows
CASL |Nimble Storage |2010 |Linux
VMFS5 |VMware |2011 |vSphere 5.0+
ReFS |Microsoft |2012 |Windows Server 2012
F2FS |Samsung Electronics |2012 |Linux
APFS |Apple Computer |2016 |macOS


LONG TEXT
---------

http://www.troff.org/faq.html

Person|Work|Quote
-|-|-
Sherlock Holmes|The Norwood Builder| You mentioned your name as if I should recognize it, but beyond the obvious facts that you are a bachelor, a solicitor, a freemason, and an asthmatic, I know nothing whatever about you.



THING TABLE
-----------

1|2
-|-
1|2
1|2
1|2
1|2
1|2
T{1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2
1|2


REPORTING BUGS
--------------



node-marked-man-0.2.0/test/md/underline_spacing_test.md000066400000000000000000000003371302237707600231130ustar00rootroot00000000000000# This input

 * `-S` _text_, `search` _text_:
    Performs a substring search of formula names for _text_.

 * `-O` , `other` :
    Does something else.

Should space text properly.


node-marked-man-0.2.0/test/out/000077500000000000000000000000001302237707600162455ustar00rootroot00000000000000node-marked-man-0.2.0/test/out/blockquotes000066400000000000000000000004341302237707600205240ustar00rootroot00000000000000T(1)                                                                      T(1)

NNAAMMEE
       tt - test

tteesstt
         A blockquote here.
         Continuing on second line.

       Hello.

                                 January 1979                             T(1)
node-marked-man-0.2.0/test/out/definition_list_syntax000066400000000000000000000010371302237707600227620ustar00rootroot00000000000000DEFITION_LIST_SYNTAX(5)                                DEFITION_LIST_SYNTAX(5)

NNAAMMEE
       ddeeffiittiioonn__lliisstt__ssyynnttaaxx - hiya

       Definition lists look like unordered lists:

       · term:
         definition

       · another one:
         The definition may span
         multiple lines and even
         start
         new paragraphs

       · ----ssoommeeaarrgg=:
         We can do that too.

                                 January 1979          DEFITION_LIST_SYNTAX(5)
node-marked-man-0.2.0/test/out/dots_at_line_start_test000066400000000000000000000006211302237707600231070ustar00rootroot00000000000000DOTS_AT_LINE_START_TEST()                            DOTS_AT_LINE_START_TEST()

NNAAMMEE
       ddoottss__aatt__lliinnee__ssttaarrtt__tteesstt

       There's a weird issue where dots at the beginning of a line
       generate troff warnings due to escaping.

       .. let's see what happens.

                                 January 1979        DOTS_AT_LINE_START_TEST()
node-marked-man-0.2.0/test/out/ellipses000066400000000000000000000005461302237707600200150ustar00rootroot00000000000000ELLIPSES(7)                                                        ELLIPSES(7)

NNAAMMEE
       eelllliippsseess - testing ellipses

       Ellipses should be replaced...

       ...also, they shouldn't interfere with regular dots at the beginning
       of a line.

                                 January 1979                      ELLIPSES(7)
node-marked-man-0.2.0/test/out/entity_encoding_test000066400000000000000000000014711302237707600224140ustar00rootroot00000000000000HELLO(1)                                                              HELLO(1)

NNAAMMEE
       hheelllloo - hello world

       Your output <i>might</i> look like this:

         * Chris
         *
         * <b>GitHub</b>
         * GitHub

       Here's some special entities:

       · •       ○

       ·  

       · ©       ©

       · ”      \

       · —      —

       · ®        ®

       · §       §

       · ≥         ≥

       · ≤         ≤

       · ≠         ≠

       · ≡      ≡

       · ±     ±

       Here's a line that uses non-breaking spaces to force the
       last few words to wrap together.

                                 January 1979                         HELLO(1)
node-marked-man-0.2.0/test/out/graves000066400000000000000000000004711302237707600174610ustar00rootroot00000000000000TEST()                                                                  TEST()

NNAAMMEE
       tteesstt

tthhiiss ttiittllee wwiillll rreennddeerr ssttrraannggeellyy
       This is the body text.

                                 January 1979                           TEST()
node-marked-man-0.2.0/test/out/links000066400000000000000000000007261302237707600173150ustar00rootroot00000000000000LINKS()                                                                LINKS()

NNAAMMEE
       lliinnkkss

       I get 10 times more traffic from Google _h_t_t_p_:_/_/_g_o_o_g_l_e_._c_o_m_/ than from
       Yahoo _h_t_t_p_:_/_/_s_e_a_r_c_h_._y_a_h_o_o_._c_o_m_/ or MSN _h_t_t_p_:_/_/_s_e_a_r_c_h_._m_s_n_._c_o_m_/.

                                 January 1979                          LINKS()
node-marked-man-0.2.0/test/out/markdown_syntax000066400000000000000000001000501302237707600214140ustar00rootroot00000000000000MARKDOWN(5)                                                        MARKDOWN(5)

NNAAMMEE
       mmaarrkkddoowwnn - humane markup syntax

SSYYNNOOPPSSIISS
         # Header 1 #
         ## Header 2 ##
         ### Header 3 ###             (Hashes on right are optional)
         #### Header 4 ####
         ##### Header 5 #####

         This is a paragraph, which is text surrounded by whitespace.
         Paragraphs can be on one line (or many), and can drone on for
         hours.

         [Reference style links][1] and [inline links](http://example.com)
         [1]: http://example.com "Title is optional"

         Inline markup like _italics_,  **bold**, and `code()`.

         ![picture alt](/images/photo.jpeg "Title is optional")

         > Blockquotes are like quoted text in email replies
         >> And, they can be nested

             code blocks are for preformatted
             text and must be indented with four spaces

         * Bullet lists are easy too
           * You can
           * even
           * nest them
         - Another one
         + Another one

DDEESSCCRRIIPPTTIIOONN
   PPhhiilloossoopphhyy
       Markdown is intended to be as easy-to-read and easy-to-write as is fea‐
       sible.

       Readability, however, is emphasized above all else. A  Markdown-format‐
       ted
       document should be publishable as-is, as plain text, without looking
       like it's been marked up with tags or formatting instructions. While
       Markdown's syntax has been influenced by several existing text-to-HTML
       filters   --   including   Setext  _h_t_t_p_:_/_/_d_o_c_u_t_i_l_s_._s_o_u_r_c_e_f_o_r_g_e_._n_e_t_/_m_i_r_‐
       _r_o_r_/_s_e_t_e_x_t_._h_t_m_l,    atx    _h_t_t_p_:_/_/_w_w_w_._a_a_r_o_n_s_w_._c_o_m_/_2_0_0_2_/_a_t_x_/,    Textile
       _h_t_t_p_:_/_/_t_e_x_t_i_s_m_._c_o_m_/_t_o_o_l_s_/_t_e_x_t_i_l_e_/,     reStructuredText    _h_t_t_p_:_/_/_d_o_c_u_‐
       _t_i_l_s_._s_o_u_r_c_e_f_o_r_g_e_._n_e_t_/_r_s_t_._h_t_m_l,
       Grutatext  _h_t_t_p_:_/_/_w_w_w_._t_r_i_p_t_i_c_o_._c_o_m_/_s_o_f_t_w_a_r_e_/_g_r_u_t_a_t_x_t_._h_t_m_l,  and  EtText
       _h_t_t_p_:_/_/_e_t_t_e_x_t_._t_a_i_n_t_._o_r_g_/_d_o_c_/ -- the single biggest source of
       inspiration for Markdown's syntax is the format of plain text email.

       To this end, Markdown's syntax is comprised entirely of punctuation
       characters, which punctuation characters have been carefully chosen so
       as to look like what they mean. E.g., asterisks around a word actually
       look like *emphasis*. Markdown lists look like, well, lists. Even
       blockquotes look like quoted passages of text, assuming you've ever
       used email.

   IInnlliinnee HHTTMMLL
       Markdown's syntax is intended for one purpose: to be used as a
       format for _w_r_i_t_i_n_g for the web.

       Markdown is not a replacement for HTML, or even close to it. Its
       syntax is very small, corresponding only to a very small subset of
       HTML tags. The idea is _n_o_t to create a syntax that makes it easier
       to insert HTML tags. In my opinion, HTML tags are already easy to
       insert. The idea for Markdown is to make it easy to read, write, and
       edit prose. HTML is a _p_u_b_l_i_s_h_i_n_g format; Markdown is a _w_r_i_t_i_n_g
       format. Thus, Markdown's formatting syntax only addresses issues that
       can be conveyed in plain text.

       For any markup that is not covered by Markdown's syntax, you simply
       use HTML itself. There's no need to preface it or delimit it to
       indicate that you're switching from Markdown to HTML; you just use
       the tags.

       The only restrictions are that block-level HTML elements -- e.g. <>,
       <>, <>, <>, etc. -- must be separated from surrounding
       content by blank lines, and the start and end tags of the block should
       not be indented with tabs or spaces. Markdown is smart enough not
       to add extra (unwanted) <> tags around HTML block-level tags.

       For example, to add an HTML table to a Markdown article:

         This is a regular paragraph.

         

             

                 Foo
             

         


         This is another regular paragraph.

       Note   that   Markdown   formatting  syntax  is  not  processed  within
       block-level
       HTML tags. E.g., you can't use Markdown-style **eemmpphhaassiiss** inside an
       HTML block.

       Span-level HTML tags -- e.g. <>, <>, or <> -- can be
       used anywhere in a Markdown paragraph, list item, or header. If you
       want, you can even use HTML tags instead of Markdown  formatting;  e.g.
       if
       you'd prefer to use HTML <> or <> tags instead of Markdown's
       link or image syntax, go right ahead.

       Unlike block-level HTML tags, Markdown syntax _i_s processed within
       span-level tags.

   AAuuttoommaattiicc EEssccaappiinngg ffoorr SSppeecciiaall CChhaarraacctteerrss
       In HTML, there are two characters that demand special treatment: <<
       and &&. Left angle brackets are used to start tags; ampersands are
       used to denote HTML entities. If you want to use them as literal
       characters, you must escape them as entities, e.g. &&lltt;;, and
       &&.

       Ampersands in particular are bedeviling for web writers. If you want to
       write about 'AT&T', you need to write 'AATT&&TT'. You even need to
       escape ampersands within URLs. Thus, if you want to link to:

         http://images.google.com/images?num=30&q=larry+bird

       you need to encode the URL as:

         http://images.google.com/images?num=30&q=larry+bird

       in your anchor tag hhrreeff attribute. Needless to say, this is easy to
       forget,  and  is probably the single most common source of HTML valida‐
       tion
       errors in otherwise well-marked-up web sites.

       Markdown allows you to use these characters naturally, taking care of
       all the necessary escaping for you. If you use an ampersand as part of
       an HTML entity, it remains unchanged; otherwise it will be translated
       into &&.

       So, if you want to include a copyright symbol in your article, you  can
       write:

         ©

       and Markdown will leave it alone. But if you write:

         AT&T

       Markdown will translate it to:

         AT&T

       Similarly, because Markdown supports inline HTML _#_h_t_m_l, if you use
       angle brackets as delimiters for HTML tags, Markdown will treat them as
       such. But if you write:

         4 < 5

       Markdown will translate it to:

         4 < 5

       However, inside Markdown code spans and blocks, angle brackets and
       ampersands are _a_l_w_a_y_s encoded automatically. This makes it easy to use
       Markdown to write about HTML code. (As opposed to raw HTML, which is a
       terrible format for writing about HTML syntax, because every single <<
       and && in your example code needs to be escaped.)

BBLLOOCCKK EELLEEMMEENNTTSS
   PPaarraaggrraapphhss aanndd LLiinnee BBrreeaakkss
       A paragraph is simply one or more consecutive lines of text, separated
       by one or more blank lines. (A blank line is any line that looks like a
       blank  line  -- a line containing nothing but spaces or tabs is consid‐
       ered
       blank.) Normal paragraphs should not be indented with spaces or tabs.

       The implication of the "one or more consecutive lines of text" rule is
       that Markdown supports "hard-wrapped" text paragraphs. This differs
       significantly from most other text-to-HTML formatters  (including  Mov‐
       able
       Type's "Convert Line Breaks" option) which translate every line break
       character in a paragraph into a <> tag.

       When you _d_o want to insert a <> break tag using Markdown, you
       end a line with two or more spaces, then type return.

       Yes, this takes a tad more effort to create a <>, but a simplistic
       "every line break is a <>" rule wouldn't work for Markdown.
       Markdown's  email-style  blockquoting  _#_b_l_o_c_k_q_u_o_t_e  and multi-paragraph
       list items _#_l_i_s_t
       work best -- and look better -- when you format them with hard breaks.

   HHeeaaddeerrss
       Markdown supports two styles of headers, Setext _h_t_t_p_:_/_/_d_o_c_u_t_i_l_s_._s_o_u_r_c_e_‐
       _f_o_r_g_e_._n_e_t_/_m_i_r_r_o_r_/_s_e_t_e_x_t_._h_t_m_l and atx _h_t_t_p_:_/_/_w_w_w_._a_a_r_o_n_s_w_._c_o_m_/_2_0_0_2_/_a_t_x_/.

       Setext-style   headers   are   "underlined"   using  equal  signs  (for
       first-level
       headers) and dashes (for second-level headers). For example:

         This is an H1
         =============

         This is an H2
         -------------

       Any number of underlining =='s or --'s will work.

       Atx-style headers use 1-6 hash characters at the start of the line,
       corresponding to header levels 1-6. For example:

         # This is an H1

         ## This is an H2

         ###### This is an H6

       Optionally, you may "close" atx-style headers. This is purely
       cosmetic -- you can use this if you think it looks better. The
       closing hashes don't even need to match the number of hashes
       used to open the header. (The number of opening hashes
       determines the header level.) :

         # This is an H1 #

         ## This is an H2 ##

         ### This is an H3 ######

   BBlloocckkqquuootteess
       Markdown uses email-style >> characters for blockquoting. If you're
       familiar with quoting passages of text in an email message, then you
       know how to create a blockquote in Markdown. It looks best if you hard
       wrap the text and put a >> before every line:

         > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
         > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
         > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
         >
         > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
         > id sem consectetuer libero luctus adipiscing.

       Markdown allows you to be lazy and only put the >> before the first
       line of a hard-wrapped paragraph:

         > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
         consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
         Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

         > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
         id sem consectetuer libero luctus adipiscing.

       Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by
       adding additional levels of >>:

         > This is the first level of quoting.
         >
         > > This is nested blockquote.
         >
         > Back to the first level.

       Blockquotes can contain other  Markdown  elements,  including  headers,
       lists,
       and code blocks:

         > ## This is a header.
         >
         > 1.   This is the first list item.
         > 2.   This is the second list item.
         >
         > Here's some example code:
         >
         >     return shell_exec("echo $input | $markdown_script");

       Any decent text editor should make email-style quoting easy. For
       example, with BBEdit, you can make a selection and choose Increase
       Quote Level from the Text menu.

   LLiissttss
       Markdown supports ordered (numbered) and unordered (bulleted) lists.

       Unordered lists use asterisks, pluses, and hyphens -- interchangably
       -- as list markers:

         *   Red
         *   Green
         *   Blue

       is equivalent to:

         +   Red
         +   Green
         +   Blue

       and:

         -   Red
         -   Green
         -   Blue

       Ordered lists use numbers followed by periods:

         1.  Bird
         2.  McHale
         3.  Parish

       It's important to note that the actual numbers you use to mark the
       list have no effect on the HTML output Markdown produces. The HTML
       Markdown produces from the above list is:

         
    
         
  1. Bird
    2. 
         
  2. McHale
    3. 
         
  3. Parish
    4. 
         


       If you instead wrote the list in Markdown like this:

         1.  Bird
         1.  McHale
         1.  Parish

       or even:

         3. Bird
         1. McHale
         8. Parish

       you'd get the exact same HTML output. The point is, if you want to,
       you can use ordinal numbers in your ordered Markdown lists, so that
       the numbers in your source match the numbers in your published HTML.
       But if you want to be lazy, you don't have to.

       If you do use lazy list numbering, however, you should still start the
       list  with the number 1. At some point in the future, Markdown may sup‐
       port
       starting ordered lists at an arbitrary number.

       List markers typically start at the left margin, but may be indented by
       up to three spaces. List markers must be followed by one or more spaces
       or a tab.

       To make lists look nice, you can wrap items with hanging indents:

         *   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
             Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
             viverra nec, fringilla in, laoreet vitae, risus.
         *   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
             Suspendisse id sem consectetuer libero luctus adipiscing.

       But if you want to be lazy, you don't have to:

         *   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
         Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
         viverra nec, fringilla in, laoreet vitae, risus.
         *   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
         Suspendisse id sem consectetuer libero luctus adipiscing.

       If list items are separated by blank lines, Markdown will wrap the
       items in <> tags in the HTML output. For example, this input:

         *   Bird
         *   Magic

       will turn into:

         
    
         
  • Bird
    • 
         
  • Magic
    • 
         


       But this:

         *   Bird

         *   Magic

       will turn into:

         
    
         
  • Bird
    • 
         
  • Magic
    • 
         


       List items may consist of multiple paragraphs. Each subsequent
       paragraph in a list item must be indented by either 4 spaces
       or one tab:

         1.  This is a list item with two paragraphs. Lorem ipsum dolor
             sit amet, consectetuer adipiscing elit. Aliquam hendrerit
             mi posuere lectus.

             Vestibulum enim wisi, viverra nec, fringilla in, laoreet
             vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
             sit amet velit.

         2.  Suspendisse id sem consectetuer libero luctus adipiscing.

       It looks nice if you indent every line of the subsequent
       paragraphs, but here again, Markdown will allow you to be
       lazy:

         *   This is a list item with two paragraphs.

             This is the second paragraph in the list item. You're
         only required to indent the first line. Lorem ipsum dolor
         sit amet, consectetuer adipiscing elit.

         *   Another item in the same list.

       To put a blockquote within a list item, the blockquote's >>
       delimiters need to be indented:

         *   A list item with a blockquote:

             > This is a blockquote
             > inside a list item.

       To put a code block within a list item, the code block needs
       to be indented _t_w_i_c_e -- 8 spaces or two tabs:

         *   A list item with a code block:

                 

       It's worth noting that it's possible to trigger an ordered list by
       accident, by writing something like this:

         1986. What a great season.

       In other words, a _n_u_m_b_e_r_-_p_e_r_i_o_d_-_s_p_a_c_e sequence at the beginning of a
       line. To avoid this, you can backslash-escape the period:

         1986\. What a great season.

   CCooddee BBlloocckkss
       Pre-formatted code blocks are used for writing about programming or
       markup source code. Rather than forming normal paragraphs, the lines
       of a code block are interpreted literally. Markdown wraps a code block
       in both <> and <> tags.

       To produce a code block in Markdown, simply indent every line of the
       block by at least 4 spaces or 1 tab. For example, given this input:

         This is a normal paragraph:

             This is a code block.

       Markdown will generate:

         
This is a normal paragraph:


         
This is a code block.
         


       One level of indentation -- 4 spaces or 1 tab -- is removed from each
       line of the code block. For example, this:

         Here is an example of AppleScript:

             tell application "Foo"
                 beep
             end tell

       will turn into:

         
Here is an example of AppleScript:


         
tell application "Foo"
             beep
         end tell
         


       A code block continues until it reaches a line that is not indented
       (or the end of the article).

       Within a code block, ampersands (&&) and angle brackets (<< and >>)
       are automatically converted into HTML entities. This makes it very
       easy to include example HTML source code using Markdown -- just paste
       it and indent it, and Markdown will handle the hassle of encoding the
       ampersands and angle brackets. For example, this:

             

                 © 2004 Foo Corporation
             


       will turn into:

         
<div class="footer">
             © 2004 Foo Corporation
         </div>
         


       Regular Markdown syntax is not processed within code blocks. E.g.,
       asterisks are just literal asterisks within a code block. This means
       it's also easy to use Markdown to write about Markdown's own syntax.

   HHoorriizzoonnttaall RRuulleess
       You can produce a horizontal rule tag (<>) by placing three or
       more hyphens, asterisks, or underscores on a line by themselves. If you
       wish, you may use spaces between the hyphens or asterisks. Each of the
       following lines will produce a horizontal rule:

         * * *

         ***

         *****

         - - -

         ---------------------------------------

SSPPAANN EELLEEMMEENNTTSS
   LLiinnkkss
       Markdown supports two style of links: _i_n_l_i_n_e and _r_e_f_e_r_e_n_c_e.

       In both styles, the link text is delimited by [square brackets].

       To create an inline link, use a set of regular parentheses immediately
       after the link text's closing square bracket. Inside the parentheses,
       put the URL where you want the link to point, along with an _o_p_t_i_o_n_a_l
       title for the link, surrounded in quotes. For example:

         This is [an example](http://example.com/ "Title") inline link.

         [This link](http://example.net/) has no title attribute.

       Will produce:

         
This is 
         an example inline link.


         
This link has no
         title attribute.


       If you're referring to a local resource on the same server, you can
       use relative paths:

         See my [About](/about/) page for details.

       Reference-style links use a second set of square brackets, inside
       which you place a label of your choosing to identify the link:

         This is [an example][id] reference-style link.

       You can optionally use a space to separate the sets of brackets:

         This is [an example] [id] reference-style link.

       Then, anywhere in the document, you define your link label like this,
       on a line by itself:

         [id]: http://example.com/  "Optional Title Here"

       That is:

       · Square brackets containing the link identifier (optionally
         indented from the left margin using up to three spaces);

       · followed by a colon;

       · followed by one or more spaces (or tabs);

       · followed by the URL for the link;

       · optionally followed by a title attribute for the link, enclosed
         in double or single quotes, or enclosed in parentheses.

       The following three link definitions are equivalent:

         [foo]: http://example.com/  "Optional Title Here"
         [foo]: http://example.com/  'Optional Title Here'
         [foo]: http://example.com/  (Optional Title Here)

       NNoottee:: There is a known bug in Markdown.pl 1.0.1 which prevents
       single quotes from being used to delimit link titles.

       The link URL may, optionally, be surrounded by angle brackets:

         [id]:   "Optional Title Here"

       You can put the title attribute on the next line and use extra spaces
       or tabs for padding, which tends to look better with longer URLs:

         [id]: http://example.com/longish/path/to/resource/here
             "Optional Title Here"

       Link definitions are only used for creating links during Markdown
       processing, and are stripped from your document in the HTML output.

       Link definition names may consist of letters, numbers, spaces, and
       punctuation -- but they are _n_o_t case sensitive. E.g. these two
       links:

         [link text][a]
         [link text][A]

       are equivalent.

       The _i_m_p_l_i_c_i_t _l_i_n_k _n_a_m_e shortcut allows you to omit the name of the
       link, in which case the link text itself is used as the name.
       Just use an empty set of square brackets -- e.g., to link the word
       "Google" to the google.com web site, you could simply write:

         [Google][]

       And then define the link:

         [Google]: http://google.com/

       Because link names may contain spaces, this shortcut even works for
       multiple words in the link text:

         Visit [Daring Fireball][] for more information.

       And then define the link:

         [Daring Fireball]: http://daringfireball.net/

       Link definitions can be placed anywhere in your Markdown document. I
       tend to put them immediately after each paragraph in which they're
       used, but if you want, you can put them all at the end of your
       document, sort of like footnotes.

       Here's an example of reference links in action:

         I get 10 times more traffic from [Google] [1] than from
         [Yahoo] [2] or [MSN] [3].

           [1]: http://google.com/        "Google"
           [2]: http://search.yahoo.com/  "Yahoo Search"
           [3]: http://search.msn.com/    "MSN Search"

       Using the implicit link name shortcut, you could instead write:

         I get 10 times more traffic from [Google][] than from
         [Yahoo][] or [MSN][].

           [google]: http://google.com/        "Google"
           [yahoo]:  http://search.yahoo.com/  "Yahoo Search"
           [msn]:    http://search.msn.com/    "MSN Search"

       Both of the above examples will produce the following HTML output:

         
I get 10 times more traffic from Google than from
         Yahoo
         or MSN.


       For comparison, here is the same paragraph written using
       Markdown's inline link style:

         I get 10 times more traffic from [Google](http://google.com/ "Google")
         than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
         [MSN](http://search.msn.com/ "MSN Search").

       The point of reference-style links is not that they're easier to
       write. The point is that with reference-style links, your document
       source is vastly more readable. Compare the above examples: using
       reference-style links, the paragraph itself is only 81 characters
       long; with inline-style links, it's 176 characters; and as raw HTML,
       it's 234 characters. In the raw HTML, there's more markup than there
       is text.

       With Markdown's reference-style links, a source document much more
       closely resembles the final output, as rendered in a browser. By
       allowing you to move the markup-related metadata out of the paragraph,
       you can add links without interrupting the narrative flow of your
       prose.

   EEmmpphhaassiiss
       Markdown treats asterisks (**) and underscores (__) as indicators of
       emphasis. Text wrapped with one ** or __ will be wrapped with an
       HTML <> tag; double **'s or __'s will be wrapped with an HTML
       <> tag. E.g., this input:

         *single asterisks*

         _single underscores_

         **double asterisks**

         __double underscores__

       will produce:

         single asterisks

         single underscores

         double asterisks

         double underscores

       You can use whichever style you prefer; the lone restriction is that
       the same character must be used to open and close an emphasis span.

       Emphasis can be used in the middle of a word:

         un*frigging*believable

       But if you surround an ** or __ with spaces, it'll be treated as a
       literal asterisk or underscore.

       To produce a literal asterisk or underscore at a position where it
       would otherwise be used as an emphasis delimiter, you can backslash
       escape it:

         \*this text is surrounded by literal asterisks\*

   CCooddee
       To indicate a span of code, wrap it with backtick quotes (`` ).
       Unlike a pre-formatted code block, a code span indicates code within a
       normal paragraph. For example:

         Use the `printf()` function.

       will produce:

         
Use the printf() function.


       To include a literal backtick character within a code span, you can use
       multiple backticks as the opening and closing delimiters:

         ``There is a literal backtick (`) here.``

       which will produce this:

         
There is a literal backtick (`) here.


       The backtick delimiters surrounding a code span may include spaces --
       one after the opening, one before the closing. This allows you to place
       literal backtick characters at the beginning or end of a code span:

         A single backtick in a code span: `` ` ``

         A backtick-delimited string in a code span: `` `foo` ``

       will produce:

         
A single backtick in a code span: `


         
A backtick-delimited string in a code span: `foo`


       With a code span, ampersands and angle brackets are encoded as HTML
       entities automatically, which makes it easy to include example HTML
       tags. Markdown will turn this:

         Please don't use any `` tags.

       into:

         
Please don't use any <blink> tags.


       You can write this:

         `—` is the decimal-encoded equivalent of `—`.

       to produce:

         
— is the decimal-encoded
         equivalent of &mdash;.


   IImmaaggeess
       Admittedly, it's fairly difficult to devise a "natural" syntax for
       placing images into a plain text document format.

       Markdown uses an image syntax that is intended to resemble the syntax
       for links, allowing for two styles: _i_n_l_i_n_e and _r_e_f_e_r_e_n_c_e.

       Inline image syntax looks like this:

         ![Alt text](/path/to/img.jpg)

         ![Alt text](/path/to/img.jpg "Optional title")

       That is:

       · An exclamation mark: !!;

       · followed by a set of square brackets, containing the aalltt
         attribute text for the image;

       · followed by a set of parentheses, containing the URL or path to
         the image, and an optional ttiittllee attribute enclosed in double
         or single quotes.

       Reference-style image syntax looks like this:

         ![Alt text][id]

       Where "id" is the name of a defined image reference. Image references
       are defined using syntax identical to link references:

         [id]: url/to/image  "Optional title attribute"

       As of this writing, Markdown has no syntax for specifying the
       dimensions of an image; if this is important to you, you can simply
       use regular HTML <> tags.

MMIISSCCEELLLLAANNEEOOUUSS
   AAuuttoommaattiicc LLiinnkkss
       Markdown supports a shortcut style for creating "automatic"  links  for
       URLs and email addresses: simply surround the URL or email address with
       angle brackets. What this means is that if you want to show the  actual
       text  of  a URL or email address, and also have it be a clickable link,
       you can do this:

         

       Markdown will turn this into:

         http://example.com/

       Automatic links for email addresses work similarly, except that
       Markdown will also perform a bit of randomized decimal and hex
       entity-encoding to help obscure your address from address-harvesting
       spambots. For example, Markdown will turn this:

         

       into something like this:

         address@exa
         mple.com

       which will render in a browser as a clickable  link  to  "address@exam‐
       ple.com".

       (This sort of entity-encoding trick will indeed fool many, if not
       most, address-harvesting bots, but it definitely won't fool all of
       them. It's better than nothing, but an address published in this way
       will probably eventually start receiving spam.)

   BBaacckkssllaasshh EEssccaappeess
       Markdown allows you to use backslash escapes to generate literal
       characters which would otherwise have special meaning in Markdown's
       formatting syntax. For example, if you wanted to surround a word
       with literal asterisks (instead of an HTML <> tag), you can use
       backslashes before the asterisks, like this:

         \*literal asterisks\*

       Markdown provides backslash escapes for the following characters:

         \   backslash
         `   backtick
         *   asterisk
         _   underscore
         {}  curly braces
         []  square brackets
         ()  parentheses
         #   hash mark
         +   plus sign
         -   minus sign (hyphen)
         .   dot
         !   exclamation mark

AAUUTTHHOORR
       Markdown was created by John Gruber.

       Manual page by Ryan Tomayko. It's pretty much a direct copy of the
       Markdown   Syntax   Reference  _h_t_t_p_:_/_/_d_a_r_i_n_g_f_i_r_e_b_a_l_l_._n_e_t_/_p_r_o_j_e_c_t_s_/_m_a_r_k_‐
       _d_o_w_n_/_s_y_n_t_a_x,
       also by John Gruber.

SSEEEE AALLSSOO
       ronn(5)
       http://daringfireball.net/projects/markdown/

                                 January 1979                      MARKDOWN(5)
node-marked-man-0.2.0/test/out/nested_list_with_code000066400000000000000000000006771302237707600225440ustar00rootroot00000000000000A(1)                                                                      A(1)

NNAAMMEE
       aa

       · ttooggggllee__ssttaattuuss

       · Toggle the display of the status bar.

       · ssppaawwnn  <>  <> TODO explain path-alike expan‐
         sion

                                 January 1979                             A(1)
node-marked-man-0.2.0/test/out/pre_block_with_quotes000066400000000000000000000003401302237707600225600ustar00rootroot00000000000000T(1)                                                                      T(1)

NNAAMMEE
       tt - test

tteesstt
         [ "$11" ]

                                 January 1979                             T(1)
node-marked-man-0.2.0/test/out/table000066400000000000000000000436011302237707600172630ustar00rootroot00000000000000TABLE(7)                                                              TABLE(7)

NNAAMMEE
       ttaabbllee - test data for table format

       test table copy and paste form www.

LLAARRGGEE TTAABBLLEE
       https://en.wikipedia.org/wiki/Comparison_of_file_systems

       ┌──────────────────────────────────────────────────────────────────────┐
       │File system      Creator           Year  of  intro‐  Original operat‐ │
       │                                   duction           ing system       │
       ├──────────────────────────────────────────────────────────────────────┤
       │DECtape          DEC               1964              PDP-6 Monitor    │
       │DASD             IBM               1964              OS/360           │
       │Level-D          DEC               1968              TOPS-10          │
       │George 2         ICT (later ICL)   1968              George 2         │
       │Version  6  Unix Bell Labs         1972              Version 6 Unix   │
       │file      system                                                      │
       │(V6FS)                                                                │
       │RT-11  file sys‐ DEC               1973              RT-11            │
       │tem                                                                   │
       │Disk   Operating GEC               1973              Core   Operating │
       │System (GEC DOS)                                     System           │
       │CP/M file system Digital Research  1974              CP/M[1][2]       │
       │                 (Gary Kildall)                                       │
       │ODS-1            DEC               1975              RSX-11           │
       │GEC  DOS  filing GEC               1977              OS4000           │
       │system extended                                                       │
       │FAT (8-bit)      Microsoft  (Marc  1977              Microsoft Stand‐ │
       │                 McDonald)    for                    alone       Disk │
       │                 NCR                                 BASIC-80  (later │
       │                                                     Microsoft Stand‐ │
       │                                                     alone       Disk │
       │                                                     BASIC-86)        │
       │DOS 3.x          Apple Computer    1978              Apple DOS        │
       │Pascal           Apple Computer    1978              Apple Pascal     │
       │CBM DOS          Commodore         1978              Commodore BASIC  │
       │Version  7  Unix Bell Labs         1979              Version 7 Unix   │
       │file      system                                                      │
       │(V7FS)                                                                │
       │ODS-2            DEC               1979              OpenVMS          │
       │FAT12            Seattle Computer  1980              QDOS/86-DOS      │
       │                 Products    (Tim                    (later  IBM   PC │
       │                 Paterson)                           DOS 1.0)         │
       │DFS              Acorn  Computers  1982              Acorn BBC  Micro │
       │                 Ltd                                 MOS              │
       │ADFS             Acorn  Computers  1983              Acorn   Electron │
       │                 Ltd                                 (later    Arthur │
       │                                                     RISC OS)         │
       │FFS              Kirk McKusick     1983              4.2BSD           │
       │ProDOS           Apple Computer    1983              ProDOS 8         │
       │FAT16            IBM, Microsoft    1984              PC   DOS    3.0, │
       │                                                     MS-DOS 3.0       │
       │MFS              Apple Computer    1984              System 1         │
       │Elektronika   BK NPO  "Scientific  1985              Vilnius   Basic, │
       │tape format      centre"     (now                    BK  monitor pro‐ │
       │                 Sitronics)                          gram             │
       │HFS              Apple Computer    1985              System 2.1       │
       │Amiga OFS[1]     Metacomco    for  1985              Amiga OS         │
       │                 Commodore                                            │
       │NWFS             Novell            1985              NetWare 286      │
       │High Sierra      Ecma    Interna‐  1986              MSCDEX       for │
       │                 tional                              MS-DOS           │
       │                                                     3.1/3.2[3]       │
       │FAT16B           Compaq            1987              Compaq    MS-DOS │
       │                                                     3.31             │
       │Minix V1 FS      Andrew S. Tanen‐  1987              MINIX 1.0        │
       │                 baum                                                 │
       │Amiga FFS        Commodore         1988              Amiga OS 1.3     │
       │ISO 9660:1988    Ecma    Interna‐  1988              MS-DOS,   "clas‐ │
       │                 tional, ISO                         sic" Mac OS, and │
       │                                                     AmigaOS          │
       │HPFS             IBM & Microsoft   1989              OS/2 1.2         │
       │JFS1             IBM               1990              AIX[a]           │
       │VxFS             VERITAS           1991              SVR4.0           │
       │ext              Rémy Card         1992              Linux            │
       │AdvFS            DEC               1993[4]           Digital Unix     │
       │NTFS             Microsoft  (Gary  1993              Windows NT 3.1   │
       │                 Kimura,      Tom                                     │
       │                 Miller)                                              │
       │LFS              Margo Seltzer     1993              Berkeley Sprite  │
       │ext2             Rémy Card         1993              Linux, Hurd      │
       │Xiafs            Q. Frank Xia      1993              Linux            │
       │UFS1             Kirk McKusick     1994              4.4BSD           │
       │XFS              SGI               1994              IRIX,     Linux, │
       │                                                     FreeBSD          │
       │HFS              IBM               1994              MVS/ESA     (now │
       │                                                     z/OS)            │
       │FAT16X           Microsoft         1995              MS-DOS   7.0   / │
       │                                                     Windows 95       │
       │Joliet ("CDFS")  Microsoft         1995              Microsoft   Win‐ │
       │                                                     dows,     Linux, │
       │                                                     "classic"    Mac │
       │                                                     OS, and FreeBSD  │
       │UDF              ISO/ECMA/OSTA     1995              N/A              │
       │FAT32, FAT32X    Microsoft         1996              MS-DOS   7.10  / │
       │                                                     Windows       95 │
       │                                                     OSR2[b]          │
       │QFS              Sun Microsystems  1996              Solaris          │
       │GPFS             IBM               1996              AIX, Linux       │
       │Be File System   Be    Inc.   (D.  1996              BeOS             │
       │                 Giampaolo, Cyril                                     │
       │                 Meurillon)                                           │
       │Minix V2 FS      Andrew S. Tanen‐  1997              MINIX 2.0        │
       │                 baum                                                 │
       │HFS Plus         Apple Computer    1998              Mac OS 8.1       │
       │NSS              Novell            1998              NetWare 5        │
       │PolyServe   File PolyServe         1998              Windows, Linux   │
       │System (PSFS)                                                         │
       │ODS-5            DEC               1998              OpenVMS 7.2      │
       │WAFL             NetApp            1998              Data ONTAP       │
       │ext3             Dr.  Stephen  C.  1999              Linux            │
       │                 Tweedie                                              │
       │ISO 9660:1999    Ecma    Interna‐  1999              Microsoft   Win‐ │
       │                 tional, ISO                         dows,     Linux, │
       │                                                     "classic"    Mac │
       │                                                     OS, FreeBSD, and │
       │                                                     AmigaOS          │
       │Lustre           Cluster     File  2002              Linux            │
       │                 Systems[5]                                           │
       │JFS              IBM               1999              OS/2 Warp Server │
       │                                                     for e-business   │
       │GFS              Sistina     (Red  2000              Linux            │
       │                 Hat)                                                 │
       │ReiserFS         Namesys           2001              Linux            │
       │zFS              IBM               2001              z/OS (backported │
       │                                                     to OS/390)       │
       │FATX             Microsoft         2002              Xbox             │
       │UFS2             Kirk McKusick     2002              FreeBSD 5.0      │
       │OCFS             Oracle  Corpora‐  2002              Linux            │
       │                 tion                                                 │
       │VMFS2            VMware            2002              VMware       ESX │
       │                                                     Server 2.0       │
       │Fossil           Bell Labs         2003              Plan 9 version 4 │
       │Google File Sys‐ Google            2003              Linux            │
       │tem                                                                   │
       │ZFS              Sun Microsystems  2004              Solaris          │
       │Reiser4          Namesys           2004              Linux            │
       │Non-Volatile     Palm, Inc.        2004              Palm OS Garnet   │
       │File System                                                           │
       │Minix V3 FS      Andrew S. Tanen‐  2005              MINIX 3          │
       │                 baum                                                 │
       │OCFS2            Oracle  Corpora‐  2005              Linux            │
       │                 tion                                                 │
       │NILFS            NTT               2005              Linux            │
       │VMFS3            VMware            2005              VMware       ESX │
       │                                                     Server 3.0       │
       │GFS2             Red Hat           2006              Linux            │
       │ext4             various           2006              Linux            │
       │exFAT            Microsoft         2006              Windows CE 6.0   │
       │Btrfs            Oracle  Corpora‐  2007              Linux            │
       │                 tion                                                 │
       │JXFS             Hyperion  Enter‐  2008              AmigaOS 4.1      │
       │                 tainment                                             │
       │HAMMER           Matthew Dillon    2008              DragonFly    BSD │
       │                                                     2.0              │
       │LSFS             StarWind   Soft‐  2009              Linux,  FreeBSD, │
       │                 ware                                Windows          │
       │CASL             Nimble Storage    2010              Linux            │
       │VMFS5            VMware            2011              vSphere 5.0+     │
       │ReFS             Microsoft         2012              Windows   Server │
       │                                                     2012             │
       │F2FS             Samsung    Elec‐  2012              Linux            │
       │                 tronics                                              │
       │APFS             Apple Computer    2016              macOS            │
       └──────────────────────────────────────────────────────────────────────┘
LLOONNGG TTEEXXTT
       http://www.troff.org/faq.html

       ┌──────────────────────────────────────────────────────────────────────┐
       │ Person                Work                      Quote                │
       ├──────────────────────────────────────────────────────────────────────┤
       │ Sherlock Holmes       The Norwood Builder       You  mentioned your  │
       │                                                 name as if I should  │
       │                                                 recognize  it,  but  │
       │                                                 beyond the  obvious  │
       │                                                 facts  that you are  │
       │                                                 a    bachelor,    a  │
       │                                                 solicitor,        a  │
       │                                                 freemason,  and  an  │
       │                                                 asthmatic,  I  know  │
       │                                                 nothing    whatever  │
       │                                                 about you.           │
       └──────────────────────────────────────────────────────────────────────┘
TTHHIINNGG TTAABBLLEE
       ┌──────────────────────────────────────────────────────────────────────┐
       │            1                                          2              │
       ├──────────────────────────────────────────────────────────────────────┤
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            T{1                                        2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       │            1                                          2              │
       └──────────────────────────────────────────────────────────────────────┘
RREEPPOORRTTIINNGG BBUUGGSS
       xxxxx@xxxx.xxxx.xxxx.xx

                                 January 1979                         TABLE(7)
node-marked-man-0.2.0/test/out/underline_spacing_test000066400000000000000000000007431302237707600227240ustar00rootroot00000000000000THIS()                                                                  THIS()

NNAAMMEE
       TThhiiss

       · --SS _t_e_x_t, sseeaarrcchh _t_e_x_t:
          Performs a substring search of formula names for _t_e_x_t.

       · --OO , ootthheerr :
          Does something else.

       Should space text properly.

       

                                 January 1979                           THIS()