!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var o;"undefined"!=typeof window?o=window:"undefined"!=typeof global?o=global:"undefined"!=typeof self&&(o=self),o.commonmark=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";

var Node = require('./node');
var unescapeString = require('./common').unescapeString;

var CODE_INDENT = 4;

var InlineParser = require('./inlines');

var BLOCKTAGNAME = '(?:article|header|aside|hgroup|iframe|blockquote|hr|body|li|map|button|object|canvas|ol|caption|output|col|p|colgroup|pre|dd|progress|div|section|dl|table|td|dt|tbody|embed|textarea|fieldset|tfoot|figcaption|th|figure|thead|footer|footer|tr|form|ul|h1|h2|h3|h4|h5|h6|video|script|style)';

var HTMLBLOCKOPEN = "<(?:" + BLOCKTAGNAME + "[\\s/>]" + "|" +
        "/" + BLOCKTAGNAME + "[\\s>]" + "|" + "[?!])";

var reHtmlBlockOpen = new RegExp('^' + HTMLBLOCKOPEN, 'i');

var reHrule = /^(?:(?:\* *){3,}|(?:_ *){3,}|(?:- *){3,}) *$/;

var reMaybeSpecial = /^[#`~*+_=<>0-9-]/;

var reNonSpace = /[^ \t\n]/;

var reBulletListMarker = /^[*+-]( +|$)/;

var reOrderedListMarker = /^(\d+)([.)])( +|$)/;

var reATXHeaderMarker = /^#{1,6}(?: +|$)/;

var reCodeFence = /^`{3,}(?!.*`)|^~{3,}(?!.*~)/;

var reClosingCodeFence = /^(?:`{3,}|~{3,})(?= *$)/;

var reSetextHeaderLine = /^(?:=+|-+) *$/;

var reLineEnding = /\r\n|\n|\r/;

// Returns true if string contains only space characters.
var isBlank = function(s) {
    return !(reNonSpace.test(s));
};

var tabSpaces = ['    ', '   ', '  ', ' '];

// Convert tabs to spaces on each line using a 4-space tab stop.
var detabLine = function(text) {
    var start = 0;
    var offset;
    var lastStop = 0;

    while ((offset = text.indexOf('\t', start)) !== -1) {
        var numspaces = (offset - lastStop) % 4;
        var spaces = tabSpaces[numspaces];
        text = text.slice(0, offset) + spaces + text.slice(offset + 1);
        lastStop = offset + numspaces;
        start = lastStop;
    }

    return text;
};

// Attempt to match a regex in string s at offset offset.
// Return index of match or -1.
var matchAt = function(re, s, offset) {
    var res = s.slice(offset).match(re);
    if (res === null) {
        return -1;
    } else {
        return offset + res.index;
    }
};

// DOC PARSER

// These are methods of a Parser object, defined below.

// Returns true if block ends with a blank line, descending if needed
// into lists and sublists.
var endsWithBlankLine = function(block) {
    while (block) {
        if (block._lastLineBlank) {
            return true;
        }
        var t = block.type;
        if (t === 'List' || t === 'Item') {
            block = block._lastChild;
        } else {
            break;
        }
    }
    return false;
};

// Break out of all containing lists, resetting the tip of the
// document to the parent of the highest list, and finalizing
// all the lists.  (This is used to implement the "two blank lines
// break of of all lists" feature.)
var breakOutOfLists = function(block) {
    var b = block;
    var last_list = null;
    do {
        if (b.type === 'List') {
            last_list = b;
        }
        b = b._parent;
    } while (b);

    if (last_list) {
        while (block !== last_list) {
            this.finalize(block, this.lineNumber);
            block = block._parent;
        }
        this.finalize(last_list, this.lineNumber);
        this.tip = last_list._parent;
    }
};

// Add a line to the block at the tip.  We assume the tip
// can accept lines -- that check should be done before calling this.
var addLine = function(ln) {
    this.tip._string_content += ln.slice(this.offset) + '\n';
};

// Add block of type tag as a child of the tip.  If the tip can't
// accept children, close and finalize it and try its parent,
// and so on til we find a block that can accept children.
var addChild = function(tag, offset) {
    while (!this.blocks[this.tip.type].canContain(tag)) {
        this.finalize(this.tip, this.lineNumber - 1);
    }

    var column_number = offset + 1; // offset 0 = column 1
    var newBlock = new Node(tag, [[this.lineNumber, column_number], [0, 0]]);
    newBlock._string_content = '';
    this.tip.appendChild(newBlock);
    this.tip = newBlock;
    return newBlock;
};

// Parse a list marker and return data on the marker (type,
// start, delimiter, bullet character, padding) or null.
var parseListMarker = function(ln, offset, indent) {
    var rest = ln.slice(offset);
    var match;
    var spaces_after_marker;
    var data = { type: null,
                 tight: true,  // lists are tight by default
                 bulletChar: null,
                 start: null,
                 delimiter: null,
                 padding: null,
                 markerOffset: indent };
    if (rest.match(reHrule)) {
        return null;
    }
    if ((match = rest.match(reBulletListMarker))) {
        spaces_after_marker = match[1].length;
        data.type = 'Bullet';
        data.bulletChar = match[0][0];

    } else if ((match = rest.match(reOrderedListMarker))) {
        spaces_after_marker = match[3].length;
        data.type = 'Ordered';
        data.start = parseInt(match[1]);
        data.delimiter = match[2];
    } else {
        return null;
    }
    var blank_item = match[0].length === rest.length;
    if (spaces_after_marker >= 5 ||
        spaces_after_marker < 1 ||
        blank_item) {
        data.padding = match[0].length - spaces_after_marker + 1;
    } else {
        data.padding = match[0].length;
    }
    return data;
};

// Returns true if the two list items are of the same type,
// with the same delimiter and bullet character.  This is used
// in agglomerating list items into lists.
var listsMatch = function(list_data, item_data) {
    return (list_data.type === item_data.type &&
            list_data.delimiter === item_data.delimiter &&
            list_data.bulletChar === item_data.bulletChar);
};

// Finalize and close any unmatched blocks. Returns true.
var closeUnmatchedBlocks = function() {
    if (!this.allClosed) {
        // finalize any blocks not matched
        while (this.oldtip !== this.lastMatchedContainer) {
            var parent = this.oldtip._parent;
            this.finalize(this.oldtip, this.lineNumber - 1);
            this.oldtip = parent;
        }
        this.allClosed = true;
    }
};

// 'finalize' is run when the block is closed.
// 'continue' is run to check whether the block is continuing
// at a certain line and offset (e.g. whether a block quote
// contains a `>`.  It returns 0 for matched, 1 for not matched,
// and 2 for "we've dealt with this line completely, go to next."
var blocks = {
    Document: {
        continue: function() { return 0; },
        finalize: function() { return; },
        canContain: function(t) { return (t !== 'Item'); },
        acceptsLines: false
    },
    List: {
        continue: function() { return 0; },
        finalize: function(parser, block) {
            var item = block._firstChild;
            while (item) {
                // check for non-final list item ending with blank line:
                if (endsWithBlankLine(item) && item._next) {
                    block._listData.tight = false;
                    break;
                }
                // recurse into children of list item, to see if there are
                // spaces between any of them:
                var subitem = item._firstChild;
                while (subitem) {
                    if (endsWithBlankLine(subitem) &&
                        (item._next || subitem._next)) {
                        block._listData.tight = false;
                        break;
                    }
                    subitem = subitem._next;
                }
                item = item._next;
            }
        },
        canContain: function(t) { return (t === 'Item'); },
        acceptsLines: false
    },
    BlockQuote: {
        continue: function(parser, container, nextNonspace) {
            var ln = parser.currentLine;
            if (nextNonspace - parser.offset <= 3 &&
                ln.charAt(nextNonspace) === '>') {
                parser.offset = nextNonspace + 1;
                if (ln.charAt(parser.offset) === ' ') {
                    parser.offset++;
                }
            } else {
                return 1;
            }
            return 0;
        },
        finalize: function() { return; },
        canContain: function(t) { return (t !== 'Item'); },
        acceptsLines: false
    },
    Item: {
        continue: function(parser, container, nextNonspace) {
            if (nextNonspace === parser.currentLine.length) { // blank
                parser.offset = nextNonspace;
            } else if (nextNonspace - parser.offset >=
                       container._listData.markerOffset +
                       container._listData.padding) {
                parser.offset += container._listData.markerOffset +
                    container._listData.padding;
            } else {
                return 1;
            }
            return 0;
        },
        finalize: function() { return; },
        canContain: function(t) { return (t !== 'Item'); },
        acceptsLines: false
    },
    Header: {
        continue: function() {
            // a header can never container > 1 line, so fail to match:
            return 1;
        },
        finalize: function() { return; },
        canContain: function() { return false; },
        acceptsLines: false
    },
    HorizontalRule: {
        continue: function() {
            // an hrule can never container > 1 line, so fail to match:
            return 1;
        },
        finalize: function() { return; },
        canContain: function() { return false; },
        acceptsLines: false
    },
    CodeBlock: {
        continue: function(parser, container, nextNonspace) {
            var ln = parser.currentLine;
            var indent = nextNonspace - parser.offset;
            if (container._isFenced) { // fenced
                var match = (indent <= 3 &&
                    ln.charAt(nextNonspace) === container._fenceChar &&
                    ln.slice(nextNonspace).match(reClosingCodeFence));
                if (match && match[0].length >= container._fenceLength) {
                    // closing fence - we're at end of line, so we can return
                    parser.finalize(container, parser.lineNumber);
                    return 2;
                } else {
                    // skip optional spaces of fence offset
                    var i = container._fenceOffset;
                    while (i > 0 && ln.charAt(parser.offset) === ' ') {
                        parser.offset++;
                        i--;
                    }
                }
            } else { // indented
                if (indent >= CODE_INDENT) {
                    parser.offset += CODE_INDENT;
                } else if (nextNonspace === ln.length) { // blank
                    parser.offset = nextNonspace;
                } else {
                    return 1;
                }
            }
            return 0;
        },
        finalize: function(parser, block) {
            if (block._isFenced) { // fenced
                // first line becomes info string
                var content = block._string_content;
                var newlinePos = content.indexOf('\n');
                var firstLine = content.slice(0, newlinePos);
                var rest = content.slice(newlinePos + 1);
                block.info = unescapeString(firstLine.trim());
                block._literal = rest;
            } else { // indented
                block._literal = block._string_content.replace(/(\n *)+$/, '\n');
            }
            block._string_content = null; // allow GC
        },
        canContain: function() { return false; },
        acceptsLines: true
    },
    HtmlBlock: {
        continue: function(parser, container, nextNonspace) {
            return (nextNonspace === parser.currentLine.length ? 1 : 0);
        },
        finalize: function(parser, block) {
            block._literal = block._string_content.replace(/(\n *)+$/, '');
            block._string_content = null; // allow GC
        },
        canContain: function() { return false; },
        acceptsLines: true
    },
    Paragraph: {
        continue: function(parser, container, nextNonspace) {
            return (nextNonspace === parser.currentLine.length ? 1 : 0);
        },
        finalize: function(parser, block) {
            var pos;
            var hasReferenceDefs = false;

            // try parsing the beginning as link reference definitions:
            while (block._string_content.charAt(0) === '[' &&
                   (pos =
                    parser.inlineParser.parseReference(block._string_content,
                                                       parser.refmap))) {
                block._string_content = block._string_content.slice(pos);
                hasReferenceDefs = true;
            }
            if (hasReferenceDefs && isBlank(block._string_content)) {
                block.unlink();
            }
        },
        canContain: function() { return false; },
        acceptsLines: true
    }
};

// Analyze a line of text and update the document appropriately.
// We parse markdown text by calling this on each line of input,
// then finalizing the document.
var incorporateLine = function(ln) {
    var all_matched = true;
    var nextNonspace;
    var match;
    var data;
    var blank;
    var indent;
    var t;

    var container = this.doc;
    this.oldtip = this.tip;
    this.offset = 0;
    this.lineNumber += 1;

    // replace NUL characters for security
    if (ln.indexOf('\u0000') !== -1) {
        ln = ln.replace(/\0/g, '\uFFFD');
    }

    // Convert tabs to spaces:
    ln = detabLine(ln);
    this.currentLine = ln;

    // For each containing block, try to parse the associated line start.
    // Bail out on failure: container will point to the last matching block.
    // Set all_matched to false if not all containers match.
    var lastChild;
    while ((lastChild = container._lastChild) && lastChild._open) {
        container = lastChild;

        match = matchAt(reNonSpace, ln, this.offset);
        if (match === -1) {
            nextNonspace = ln.length;
        } else {
            nextNonspace = match;
        }

        switch (this.blocks[container.type].continue(this, container, nextNonspace)) {
        case 0: // we've matched, keep going
            break;
        case 1: // we've failed to match a block
            all_matched = false;
            break;
        case 2: // we've hit end of line for fenced code close and can return
            this.lastLineLength = ln.length;
            return;
        default:
            throw 'continue returned illegal value, must be 0, 1, or 2';
        }
        if (!all_matched) {
            container = container._parent; // back up to last matching block
            break;
        }
    }

    blank = nextNonspace === ln.length;

    this.allClosed = (container === this.oldtip);
    this.lastMatchedContainer = container;

    // Check to see if we've hit 2nd blank line; if so break out of list:
    if (blank && container._lastLineBlank) {
        this.breakOutOfLists(container);
    }

    // Unless last matched container is a code block, try new container starts,
    // adding children to the last matched container:
    while ((t = container.type) && !(t === 'CodeBlock' || t === 'HtmlBlock')) {

        match = matchAt(reNonSpace, ln, this.offset);
        if (match === -1) {
            nextNonspace = ln.length;
            blank = true;
            break;
        } else {
            nextNonspace = match;
            blank = false;
        }
        indent = nextNonspace - this.offset;

        // this is a little performance optimization:
        if (indent < CODE_INDENT && !reMaybeSpecial.test(ln.slice(nextNonspace))) {
            this.offset = nextNonspace;
            break;
        }

        if (indent >= CODE_INDENT) {
            if (this.tip.type !== 'Paragraph' && !blank) {
                // indented code
                this.offset += CODE_INDENT;
                this.closeUnmatchedBlocks();
                container = this.addChild('CodeBlock', this.offset);
            } else {
                // lazy paragraph continuation
                this.offset = nextNonspace;
            }
            break;

        } else if (ln.charAt(nextNonspace) === '>') {
            // blockquote
            this.offset = nextNonspace + 1;
            // optional following space
            if (ln.charAt(this.offset) === ' ') {
                this.offset++;
            }
            this.closeUnmatchedBlocks();
            container = this.addChild('BlockQuote', nextNonspace);

        } else if ((match = ln.slice(nextNonspace).match(reATXHeaderMarker))) {
            // ATX header
            this.offset = nextNonspace + match[0].length;
            this.closeUnmatchedBlocks();
            container = this.addChild('Header', nextNonspace);
            container.level = match[0].trim().length; // number of #s
            // remove trailing ###s:
            container._string_content =
                ln.slice(this.offset).replace(/^ *#+ *$/, '').replace(/ +#+ *$/, '');
            this.offset = ln.length;
            break;

        } else if ((match = ln.slice(nextNonspace).match(reCodeFence))) {
            // fenced code block
            var fenceLength = match[0].length;
            this.closeUnmatchedBlocks();
            container = this.addChild('CodeBlock', nextNonspace);
            container._isFenced = true;
            container._fenceLength = fenceLength;
            container._fenceChar = match[0][0];
            container._fenceOffset = indent;
            this.offset = nextNonspace + fenceLength;

        } else if (matchAt(reHtmlBlockOpen, ln, nextNonspace) !== -1) {
            // html block
            this.closeUnmatchedBlocks();
            container = this.addChild('HtmlBlock', this.offset);
            // don't adjust this.offset; spaces are part of block
            break;

        } else if (t === 'Paragraph' &&
                   (container._string_content.indexOf('\n') ===
                      container._string_content.length - 1) &&
                   ((match = ln.slice(nextNonspace).match(reSetextHeaderLine)))) {
            // setext header line
            this.closeUnmatchedBlocks();
            var header = new Node('Header', container.sourcepos);
            header.level = match[0][0] === '=' ? 1 : 2;
            header._string_content = container._string_content;
            container.insertAfter(header);
            container.unlink();
            container = header;
            this.tip = header;
            this.offset = ln.length;
            break;

        } else if (matchAt(reHrule, ln, nextNonspace) !== -1) {
            // hrule
            this.closeUnmatchedBlocks();
            container = this.addChild('HorizontalRule', nextNonspace);
            this.offset = ln.length;
            break;

        } else if ((data = parseListMarker(ln, nextNonspace, indent))) {
            // list item
            this.closeUnmatchedBlocks();
            this.offset = nextNonspace + data.padding;

            // add the list if needed
            if (t !== 'List' ||
                !(listsMatch(container._listData, data))) {
                container = this.addChild('List', nextNonspace);
                container._listData = data;
            }

            // add the list item
            container = this.addChild('Item', nextNonspace);
            container._listData = data;

        } else {
            this.offset = nextNonspace;
            break;

        }

    }

    // What remains at the offset is a text line.  Add the text to the
    // appropriate container.

   // First check for a lazy paragraph continuation:
    if (!this.allClosed && !blank &&
        this.tip.type === 'Paragraph') {
        // lazy paragraph continuation
        this.addLine(ln);

    } else { // not a lazy continuation

        // finalize any blocks not matched
        this.closeUnmatchedBlocks();
        if (blank && container.lastChild) {
            container.lastChild._lastLineBlank = true;
        }

        t = container.type;

        // Block quote lines are never blank as they start with >
        // and we don't count blanks in fenced code for purposes of tight/loose
        // lists or breaking out of lists.  We also don't set _lastLineBlank
        // on an empty list item, or if we just closed a fenced block.
        var lastLineBlank = blank &&
            !(t === 'BlockQuote' ||
              (t === 'CodeBlock' && container._isFenced) ||
              (t === 'Item' &&
               !container._firstChild &&
               container.sourcepos[0][0] === this.lineNumber));

        // propagate lastLineBlank up through parents:
        var cont = container;
        while (cont) {
            cont._lastLineBlank = lastLineBlank;
            cont = cont._parent;
        }

        if (this.blocks[t].acceptsLines) {
            this.addLine(ln);
        } else if (this.offset < ln.length && !blank) {
            // create paragraph container for line
            container = this.addChild('Paragraph', this.offset);
            this.offset = nextNonspace;
            this.addLine(ln);
        }
    }
    this.lastLineLength = ln.length;
};

// Finalize a block.  Close it and do any necessary postprocessing,
// e.g. creating string_content from strings, setting the 'tight'
// or 'loose' status of a list, and parsing the beginnings
// of paragraphs for reference definitions.  Reset the tip to the
// parent of the closed block.
var finalize = function(block, lineNumber) {
    var above = block._parent || this.top;
    block._open = false;
    block.sourcepos[1] = [lineNumber, this.lastLineLength];

    this.blocks[block.type].finalize(this, block);

    this.tip = above;
};

// Walk through a block & children recursively, parsing string content
// into inline content where appropriate.  Returns new object.
var processInlines = function(block) {
    var node, event, t;
    var walker = block.walker();
    this.inlineParser.refmap = this.refmap;
    while ((event = walker.next())) {
        node = event.node;
        t = node.type;
        if (!event.entering && (t === 'Paragraph' || t === 'Header')) {
            this.inlineParser.parse(node);
        }
    }
};

var Document = function() {
    var doc = new Node('Document', [[1, 1], [0, 0]]);
    return doc;
};

// The main parsing function.  Returns a parsed document AST.
var parse = function(input) {
    this.doc = new Document();
    this.tip = this.doc;
    this.refmap = {};
    this.lineNumber = 0;
    this.lastLineLength = 0;
    this.offset = 0;
    this.lastMatchedContainer = this.doc;
    this.currentLine = "";
    if (this.options.time) { console.time("preparing input"); }
    var lines = input.split(reLineEnding);
    var len = lines.length;
    if (input.charAt(input.length - 1) === '\n') {
        // ignore last blank line created by final newline
        len -= 1;
    }
    if (this.options.time) { console.timeEnd("preparing input"); }
    if (this.options.time) { console.time("block parsing"); }
    for (var i = 0; i < len; i++) {
        this.incorporateLine(lines[i]);
    }
    while (this.tip) {
        this.finalize(this.tip, len);
    }
    if (this.options.time) { console.timeEnd("block parsing"); }
    if (this.options.time) { console.time("inline parsing"); }
    this.processInlines(this.doc);
    if (this.options.time) { console.timeEnd("inline parsing"); }
    return this.doc;
};


// The Parser object.
function Parser(options){
    return {
        doc: new Document(),
        blocks: blocks,
        tip: this.doc,
        oldtip: this.doc,
        currentLine: "",
        lineNumber: 0,
        offset: 0,
        allClosed: true,
        lastMatchedContainer: this.doc,
        refmap: {},
        lastLineLength: 0,
        inlineParser: new InlineParser(),
        breakOutOfLists: breakOutOfLists,
        addLine: addLine,
        addChild: addChild,
        incorporateLine: incorporateLine,
        finalize: finalize,
        processInlines: processInlines,
        closeUnmatchedBlocks: closeUnmatchedBlocks,
        parse: parse,
        options: options || {}
    };
}

module.exports = Parser;

},{"./common":2,"./inlines":7,"./node":8}],2:[function(require,module,exports){
"use strict";

var entityToChar = require('./html5-entities.js').entityToChar;

var ENTITY = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});";

var reBackslashOrAmp = /[\\&]/;

var ESCAPABLE = '[!"#$%&\'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]';

var reEntityOrEscapedChar = new RegExp('\\\\' + ESCAPABLE + '|' + ENTITY, 'gi');

var XMLSPECIAL = '[&<>"]';

var reXmlSpecial = new RegExp(XMLSPECIAL, 'g');

var reXmlSpecialOrEntity = new RegExp(ENTITY + '|' + XMLSPECIAL, 'gi');

var unescapeChar = function(s) {
    if (s[0] === '\\') {
        return s[1];
    } else {
        return entityToChar(s);
    }
};

// Replace entities and backslash escapes with literal characters.
var unescapeString = function(s) {
    if (reBackslashOrAmp.test(s)) {
        return s.replace(reEntityOrEscapedChar, unescapeChar);
    } else {
        return s;
    }
};

var normalizeURI = function(uri) {
    try {
        return encodeURI(decodeURI(uri));
    }
    catch(err) {
        return uri;
    }
};

var replaceUnsafeChar = function(s) {
    switch (s) {
    case '&':
        return '&amp;';
    case '<':
        return '&lt;';
    case '>':
        return '&gt;';
    case '"':
        return '&quot;';
    default:
        return s;
    }
};

var escapeXml = function(s, preserve_entities) {
    if (reXmlSpecial.test(s)) {
        if (preserve_entities) {
            return s.replace(reXmlSpecialOrEntity, replaceUnsafeChar);
        } else {
            return s.replace(reXmlSpecial, replaceUnsafeChar);
        }
    } else {
        return s;
    }
};

module.exports = { unescapeString: unescapeString,
                   normalizeURI: normalizeURI,
                   escapeXml: escapeXml
                 };

},{"./html5-entities.js":5}],3:[function(require,module,exports){
"use strict";

// derived from https://github.com/mathiasbynens/String.fromCodePoint
/*! http://mths.be/fromcodepoint v0.2.1 by @mathias */
if (String.fromCodePoint) {
    module.exports = function (_) {
        try {
            return String.fromCodePoint(_);
        } catch (e) {
            if (e instanceof RangeError) {
                return String.fromCharCode(0xFFFD);
            }
            throw e;
        }
    };

} else {

  var stringFromCharCode = String.fromCharCode;
  var floor = Math.floor;
  var fromCodePoint = function() {
      var MAX_SIZE = 0x4000;
      var codeUnits = [];
      var highSurrogate;
      var lowSurrogate;
      var index = -1;
      var length = arguments.length;
      if (!length) {
          return '';
      }
      var result = '';
      while (++index < length) {
          var codePoint = Number(arguments[index]);
          if (
              !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
                  codePoint < 0 || // not a valid Unicode code point
                  codePoint > 0x10FFFF || // not a valid Unicode code point
                  floor(codePoint) !== codePoint // not an integer
          ) {
              return String.fromCharCode(0xFFFD);
          }
          if (codePoint <= 0xFFFF) { // BMP code point
              codeUnits.push(codePoint);
          } else { // Astral code point; split in surrogate halves
              // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
              codePoint -= 0x10000;
              highSurrogate = (codePoint >> 10) + 0xD800;
              lowSurrogate = (codePoint % 0x400) + 0xDC00;
              codeUnits.push(highSurrogate, lowSurrogate);
          }
          if (index + 1 === length || codeUnits.length > MAX_SIZE) {
              result += stringFromCharCode.apply(null, codeUnits);
              codeUnits.length = 0;
          }
      }
      return result;
  };
  module.exports = fromCodePoint;
}

},{}],4:[function(require,module,exports){
"use strict";

var escapeXml = require('./common').escapeXml;

// Helper function to produce an HTML tag.
var tag = function(name, attrs, selfclosing) {
    var result = '<' + name;
    if (attrs && attrs.length > 0) {
        var i = 0;
        var attrib;
        while ((attrib = attrs[i]) !== undefined) {
            result += ' ' + attrib[0] + '="' + attrib[1] + '"';
            i++;
        }
    }
    if (selfclosing) {
        result += ' /';
    }

    result += '>';
    return result;
};

var reHtmlTag = /\<[^>]*\>/;

var renderNodes = function(block) {

    var attrs;
    var info_words;
    var tagname;
    var walker = block.walker();
    var event, node, entering;
    var buffer = "";
    var lastOut = "\n";
    var disableTags = 0;
    var grandparent;
    var out = function(s) {
        if (disableTags > 0) {
            buffer += s.replace(reHtmlTag, '');
        } else {
            buffer += s;
        }
        lastOut = s;
    };
    var esc = this.escape;
    var cr = function() {
        if (lastOut !== '\n') {
            buffer += '\n';
            lastOut = '\n';
        }
    };

    var options = this.options;

    if (options.time) { console.time("rendering"); }

    while ((event = walker.next())) {
        entering = event.entering;
        node = event.node;

        attrs = [];
        if (options.sourcepos) {
            var pos = node.sourcepos;
            if (pos) {
                attrs.push(['data-sourcepos', String(pos[0][0]) + ':' +
                            String(pos[0][1]) + '-' + String(pos[1][0]) + ':' +
                            String(pos[1][1])]);
            }
        }

        switch (node.type) {
        case 'Text':
            out(esc(node.literal, false));
            break;

        case 'Softbreak':
            out(this.softbreak);
            break;

        case 'Hardbreak':
            out(tag('br', [], true));
            cr();
            break;

        case 'Emph':
            out(tag(entering ? 'em' : '/em'));
            break;

        case 'Strong':
            out(tag(entering ? 'strong' : '/strong'));
            break;

        case 'Html':
            out(node.literal);
            break;

        case 'Link':
            if (entering) {
                attrs.push(['href', esc(node.destination, true)]);
                if (node.title) {
                    attrs.push(['title', esc(node.title, true)]);
                }
                out(tag('a', attrs));
            } else {
                out(tag('/a'));
            }
            break;

        case 'Image':
            if (entering) {
                if (disableTags === 0) {
                    out('<img src="' + esc(node.destination, true) +
                        '" alt="');
                }
                disableTags += 1;
            } else {
                disableTags -= 1;
                if (disableTags === 0) {
                    if (node.title) {
                        out('" title="' + esc(node.title, true));
                    }
                    out('" />');
                }
            }
            break;

        case 'Code':
            out(tag('code') + esc(node.literal, false) + tag('/code'));
            break;

        case 'Document':
            break;

        case 'Paragraph':
            grandparent = node.parent.parent;
            if (grandparent !== null &&
                grandparent.type === 'List') {
                if (grandparent.listTight) {
                    break;
                }
            }
            if (entering) {
                cr();
                out(tag('p', attrs));
            } else {
                out(tag('/p'));
                cr();
            }
            break;

        case 'BlockQuote':
            if (entering) {
                cr();
                out(tag('blockquote', attrs));
                cr();
            } else {
                cr();
                out(tag('/blockquote'));
                cr();
            }
            break;

        case 'Item':
            if (entering) {
                out(tag('li', attrs));
            } else {
                out(tag('/li'));
                cr();
            }
            break;

        case 'List':
            tagname = node.listType === 'Bullet' ? 'ul' : 'ol';
            if (entering) {
                var start = node.listStart;
                if (start && start > 1) {
                    attrs.push(['start', start.toString()]);
                }
                cr();
                out(tag(tagname, attrs));
                cr();
            } else {
                cr();
                out(tag('/' + tagname));
                cr();
            }
            break;

        case 'Header':
            tagname = 'h' + node.level;
            if (entering) {
                cr();
                out(tag(tagname, attrs));
            } else {
                out(tag('/' + tagname));
                cr();
            }
            break;

        case 'CodeBlock':
            info_words = node.info ? node.info.split(/ +/) : [];
            if (info_words.length > 0 && info_words[0].length > 0) {
                attrs.push(['class', 'language-' + esc(info_words[0], true)]);
            }
            cr();
            out(tag('pre') + tag('code', attrs));
            out(esc(node.literal, false));
            out(tag('/code') + tag('/pre'));
            cr();
            break;

        case 'HtmlBlock':
            cr();
            out(node.literal);
            cr();
            break;

        case 'HorizontalRule':
            cr();
            out(tag('hr', attrs, true));
            cr();
            break;

        default:
            throw "Unknown node type " + node.type;
        }

    }
    if (options.time) { console.timeEnd("rendering"); }
    return buffer;
};

// The HtmlRenderer object.
function HtmlRenderer(options){
    return {
        // default options:
        softbreak: '\n', // by default, soft breaks are rendered as newlines in HTML
        // set to "<br />" to make them hard breaks
        // set to " " if you want to ignore line wrapping in source
        escape: escapeXml,
        options: options || {},
        render: renderNodes
    };
}

module.exports = HtmlRenderer;

},{"./common":2}],5:[function(require,module,exports){
"use strict";

var fromCodePoint = require('./from-code-point');

var entities = {
  AAacute: 193,
  aacute: 225,
  Abreve: 258,
  abreve: 259,
  ac: 8766,
  acd: 8767,
  acE: 8766,
  Acirc: 194,
  acirc: 226,
  acute: 180,
  Acy: 1040,
  acy: 1072,
  AElig: 198,
  aelig: 230,
  af: 8289,
  Afr: 55349,
  afr: 55349,
  Agrave: 192,
  agrave: 224,
  alefsym: 8501,
  aleph: 8501,
  Alpha: 913,
  alpha: 945,
  Amacr: 256,
  amacr: 257,
  amalg: 10815,
  amp: 38,
  AMP: 38,
  andand: 10837,
  And: 10835,
  and: 8743,
  andd: 10844,
  andslope: 10840,
  andv: 10842,
  ang: 8736,
  ange: 10660,
  angle: 8736,
  angmsdaa: 10664,
  angmsdab: 10665,
  angmsdac: 10666,
  angmsdad: 10667,
  angmsdae: 10668,
  angmsdaf: 10669,
  angmsdag: 10670,
  angmsdah: 10671,
  angmsd: 8737,
  angrt: 8735,
  angrtvb: 8894,
  angrtvbd: 10653,
  angsph: 8738,
  angst: 197,
  angzarr: 9084,
  Aogon: 260,
  aogon: 261,
  Aopf: 55349,
  aopf: 55349,
  apacir: 10863,
  ap: 8776,
  apE: 10864,
  ape: 8778,
  apid: 8779,
  apos: 39,
  ApplyFunction: 8289,
  approx: 8776,
  approxeq: 8778,
  Aring: 197,
  aring: 229,
  Ascr: 55349,
  ascr: 55349,
  Assign: 8788,
  ast: 42,
  asymp: 8776,
  asympeq: 8781,
  Atilde: 195,
  atilde: 227,
  Auml: 196,
  auml: 228,
  awconint: 8755,
  awint: 10769,
  backcong: 8780,
  backepsilon: 1014,
  backprime: 8245,
  backsim: 8765,
  backsimeq: 8909,
  Backslash: 8726,
  Barv: 10983,
  barvee: 8893,
  barwed: 8965,
  Barwed: 8966,
  barwedge: 8965,
  bbrk: 9141,
  bbrktbrk: 9142,
  bcong: 8780,
  Bcy: 1041,
  bcy: 1073,
  bdquo: 8222,
  becaus: 8757,
  because: 8757,
  Because: 8757,
  bemptyv: 10672,
  bepsi: 1014,
  bernou: 8492,
  Bernoullis: 8492,
  Beta: 914,
  beta: 946,
  beth: 8502,
  between: 8812,
  Bfr: 55349,
  bfr: 55349,
  bigcap: 8898,
  bigcirc: 9711,
  bigcup: 8899,
  bigodot: 10752,
  bigoplus: 10753,
  bigotimes: 10754,
  bigsqcup: 10758,
  bigstar: 9733,
  bigtriangledown: 9661,
  bigtriangleup: 9651,
  biguplus: 10756,
  bigvee: 8897,
  bigwedge: 8896,
  bkarow: 10509,
  blacklozenge: 10731,
  blacksquare: 9642,
  blacktriangle: 9652,
  blacktriangledown: 9662,
  blacktriangleleft: 9666,
  blacktriangleright: 9656,
  blank: 9251,
  blk12: 9618,
  blk14: 9617,
  blk34: 9619,
  block: 9608,
  bne: 61,
  bnequiv: 8801,
  bNot: 10989,
  bnot: 8976,
  Bopf: 55349,
  bopf: 55349,
  bot: 8869,
  bottom: 8869,
  bowtie: 8904,
  boxbox: 10697,
  boxdl: 9488,
  boxdL: 9557,
  boxDl: 9558,
  boxDL: 9559,
  boxdr: 9484,
  boxdR: 9554,
  boxDr: 9555,
  boxDR: 9556,
  boxh: 9472,
  boxH: 9552,
  boxhd: 9516,
  boxHd: 9572,
  boxhD: 9573,
  boxHD: 9574,
  boxhu: 9524,
  boxHu: 9575,
  boxhU: 9576,
  boxHU: 9577,
  boxminus: 8863,
  boxplus: 8862,
  boxtimes: 8864,
  boxul: 9496,
  boxuL: 9563,
  boxUl: 9564,
  boxUL: 9565,
  boxur: 9492,
  boxuR: 9560,
  boxUr: 9561,
  boxUR: 9562,
  boxv: 9474,
  boxV: 9553,
  boxvh: 9532,
  boxvH: 9578,
  boxVh: 9579,
  boxVH: 9580,
  boxvl: 9508,
  boxvL: 9569,
  boxVl: 9570,
  boxVL: 9571,
  boxvr: 9500,
  boxvR: 9566,
  boxVr: 9567,
  boxVR: 9568,
  bprime: 8245,
  breve: 728,
  Breve: 728,
  brvbar: 166,
  bscr: 55349,
  Bscr: 8492,
  bsemi: 8271,
  bsim: 8765,
  bsime: 8909,
  bsolb: 10693,
  bsol: 92,
  bsolhsub: 10184,
  bull: 8226,
  bullet: 8226,
  bump: 8782,
  bumpE: 10926,
  bumpe: 8783,
  Bumpeq: 8782,
  bumpeq: 8783,
  Cacute: 262,
  cacute: 263,
  capand: 10820,
  capbrcup: 10825,
  capcap: 10827,
  cap: 8745,
  Cap: 8914,
  capcup: 10823,
  capdot: 10816,
  CapitalDifferentialD: 8517,
  caps: 8745,
  caret: 8257,
  caron: 711,
  Cayleys: 8493,
  ccaps: 10829,
  Ccaron: 268,
  ccaron: 269,
  Ccedil: 199,
  ccedil: 231,
  Ccirc: 264,
  ccirc: 265,
  Cconint: 8752,
  ccups: 10828,
  ccupssm: 10832,
  Cdot: 266,
  cdot: 267,
  cedil: 184,
  Cedilla: 184,
  cemptyv: 10674,
  cent: 162,
  centerdot: 183,
  CenterDot: 183,
  cfr: 55349,
  Cfr: 8493,
  CHcy: 1063,
  chcy: 1095,
  check: 10003,
  checkmark: 10003,
  Chi: 935,
  chi: 967,
  circ: 710,
  circeq: 8791,
  circlearrowleft: 8634,
  circlearrowright: 8635,
  circledast: 8859,
  circledcirc: 8858,
  circleddash: 8861,
  CircleDot: 8857,
  circledR: 174,
  circledS: 9416,
  CircleMinus: 8854,
  CirclePlus: 8853,
  CircleTimes: 8855,
  cir: 9675,
  cirE: 10691,
  cire: 8791,
  cirfnint: 10768,
  cirmid: 10991,
  cirscir: 10690,
  ClockwiseContourIntegral: 8754,
  CloseCurlyDoubleQuote: 8221,
  CloseCurlyQuote: 8217,
  clubs: 9827,
  clubsuit: 9827,
  colon: 58,
  Colon: 8759,
  Colone: 10868,
  colone: 8788,
  coloneq: 8788,
  comma: 44,
  commat: 64,
  comp: 8705,
  compfn: 8728,
  complement: 8705,
  complexes: 8450,
  cong: 8773,
  congdot: 10861,
  Congruent: 8801,
  conint: 8750,
  Conint: 8751,
  ContourIntegral: 8750,
  copf: 55349,
  Copf: 8450,
  coprod: 8720,
  Coproduct: 8720,
  copy: 169,
  COPY: 169,
  copysr: 8471,
  CounterClockwiseContourIntegral: 8755,
  crarr: 8629,
  cross: 10007,
  Cross: 10799,
  Cscr: 55349,
  cscr: 55349,
  csub: 10959,
  csube: 10961,
  csup: 10960,
  csupe: 10962,
  ctdot: 8943,
  cudarrl: 10552,
  cudarrr: 10549,
  cuepr: 8926,
  cuesc: 8927,
  cularr: 8630,
  cularrp: 10557,
  cupbrcap: 10824,
  cupcap: 10822,
  CupCap: 8781,
  cup: 8746,
  Cup: 8915,
  cupcup: 10826,
  cupdot: 8845,
  cupor: 10821,
  cups: 8746,
  curarr: 8631,
  curarrm: 10556,
  curlyeqprec: 8926,
  curlyeqsucc: 8927,
  curlyvee: 8910,
  curlywedge: 8911,
  curren: 164,
  curvearrowleft: 8630,
  curvearrowright: 8631,
  cuvee: 8910,
  cuwed: 8911,
  cwconint: 8754,
  cwint: 8753,
  cylcty: 9005,
  dagger: 8224,
  Dagger: 8225,
  daleth: 8504,
  darr: 8595,
  Darr: 8609,
  dArr: 8659,
  dash: 8208,
  Dashv: 10980,
  dashv: 8867,
  dbkarow: 10511,
  dblac: 733,
  Dcaron: 270,
  dcaron: 271,
  Dcy: 1044,
  dcy: 1076,
  ddagger: 8225,
  ddarr: 8650,
  DD: 8517,
  dd: 8518,
  DDotrahd: 10513,
  ddotseq: 10871,
  deg: 176,
  Del: 8711,
  Delta: 916,
  delta: 948,
  demptyv: 10673,
  dfisht: 10623,
  Dfr: 55349,
  dfr: 55349,
  dHar: 10597,
  dharl: 8643,
  dharr: 8642,
  DiacriticalAcute: 180,
  DiacriticalDot: 729,
  DiacriticalDoubleAcute: 733,
  DiacriticalGrave: 96,
  DiacriticalTilde: 732,
  diam: 8900,
  diamond: 8900,
  Diamond: 8900,
  diamondsuit: 9830,
  diams: 9830,
  die: 168,
  DifferentialD: 8518,
  digamma: 989,
  disin: 8946,
  div: 247,
  divide: 247,
  divideontimes: 8903,
  divonx: 8903,
  DJcy: 1026,
  djcy: 1106,
  dlcorn: 8990,
  dlcrop: 8973,
  dollar: 36,
  Dopf: 55349,
  dopf: 55349,
  Dot: 168,
  dot: 729,
  DotDot: 8412,
  doteq: 8784,
  doteqdot: 8785,
  DotEqual: 8784,
  dotminus: 8760,
  dotplus: 8724,
  dotsquare: 8865,
  doublebarwedge: 8966,
  DoubleContourIntegral: 8751,
  DoubleDot: 168,
  DoubleDownArrow: 8659,
  DoubleLeftArrow: 8656,
  DoubleLeftRightArrow: 8660,
  DoubleLeftTee: 10980,
  DoubleLongLeftArrow: 10232,
  DoubleLongLeftRightArrow: 10234,
  DoubleLongRightArrow: 10233,
  DoubleRightArrow: 8658,
  DoubleRightTee: 8872,
  DoubleUpArrow: 8657,
  DoubleUpDownArrow: 8661,
  DoubleVerticalBar: 8741,
  DownArrowBar: 10515,
  downarrow: 8595,
  DownArrow: 8595,
  Downarrow: 8659,
  DownArrowUpArrow: 8693,
  DownBreve: 785,
  downdownarrows: 8650,
  downharpoonleft: 8643,
  downharpoonright: 8642,
  DownLeftRightVector: 10576,
  DownLeftTeeVector: 10590,
  DownLeftVectorBar: 10582,
  DownLeftVector: 8637,
  DownRightTeeVector: 10591,
  DownRightVectorBar: 10583,
  DownRightVector: 8641,
  DownTeeArrow: 8615,
  DownTee: 8868,
  drbkarow: 10512,
  drcorn: 8991,
  drcrop: 8972,
  Dscr: 55349,
  dscr: 55349,
  DScy: 1029,
  dscy: 1109,
  dsol: 10742,
  Dstrok: 272,
  dstrok: 273,
  dtdot: 8945,
  dtri: 9663,
  dtrif: 9662,
  duarr: 8693,
  duhar: 10607,
  dwangle: 10662,
  DZcy: 1039,
  dzcy: 1119,
  dzigrarr: 10239,
  Eacute: 201,
  eacute: 233,
  easter: 10862,
  Ecaron: 282,
  ecaron: 283,
  Ecirc: 202,
  ecirc: 234,
  ecir: 8790,
  ecolon: 8789,
  Ecy: 1069,
  ecy: 1101,
  eDDot: 10871,
  Edot: 278,
  edot: 279,
  eDot: 8785,
  ee: 8519,
  efDot: 8786,
  Efr: 55349,
  efr: 55349,
  eg: 10906,
  Egrave: 200,
  egrave: 232,
  egs: 10902,
  egsdot: 10904,
  el: 10905,
  Element: 8712,
  elinters: 9191,
  ell: 8467,
  els: 10901,
  elsdot: 10903,
  Emacr: 274,
  emacr: 275,
  empty: 8709,
  emptyset: 8709,
  EmptySmallSquare: 9723,
  emptyv: 8709,
  EmptyVerySmallSquare: 9643,
  emsp13: 8196,
  emsp14: 8197,
  emsp: 8195,
  ENG: 330,
  eng: 331,
  ensp: 8194,
  Eogon: 280,
  eogon: 281,
  Eopf: 55349,
  eopf: 55349,
  epar: 8917,
  eparsl: 10723,
  eplus: 10865,
  epsi: 949,
  Epsilon: 917,
  epsilon: 949,
  epsiv: 1013,
  eqcirc: 8790,
  eqcolon: 8789,
  eqsim: 8770,
  eqslantgtr: 10902,
  eqslantless: 10901,
  Equal: 10869,
  equals: 61,
  EqualTilde: 8770,
  equest: 8799,
  Equilibrium: 8652,
  equiv: 8801,
  equivDD: 10872,
  eqvparsl: 10725,
  erarr: 10609,
  erDot: 8787,
  escr: 8495,
  Escr: 8496,
  esdot: 8784,
  Esim: 10867,
  esim: 8770,
  Eta: 919,
  eta: 951,
  ETH: 208,
  eth: 240,
  Euml: 203,
  euml: 235,
  euro: 8364,
  excl: 33,
  exist: 8707,
  Exists: 8707,
  expectation: 8496,
  exponentiale: 8519,
  ExponentialE: 8519,
  fallingdotseq: 8786,
  Fcy: 1060,
  fcy: 1092,
  female: 9792,
  ffilig: 64259,
  fflig: 64256,
  ffllig: 64260,
  Ffr: 55349,
  ffr: 55349,
  filig: 64257,
  FilledSmallSquare: 9724,
  FilledVerySmallSquare: 9642,
  fjlig: 102,
  flat: 9837,
  fllig: 64258,
  fltns: 9649,
  fnof: 402,
  Fopf: 55349,
  fopf: 55349,
  forall: 8704,
  ForAll: 8704,
  fork: 8916,
  forkv: 10969,
  Fouriertrf: 8497,
  fpartint: 10765,
  frac12: 189,
  frac13: 8531,
  frac14: 188,
  frac15: 8533,
  frac16: 8537,
  frac18: 8539,
  frac23: 8532,
  frac25: 8534,
  frac34: 190,
  frac35: 8535,
  frac38: 8540,
  frac45: 8536,
  frac56: 8538,
  frac58: 8541,
  frac78: 8542,
  frasl: 8260,
  frown: 8994,
  fscr: 55349,
  Fscr: 8497,
  gacute: 501,
  Gamma: 915,
  gamma: 947,
  Gammad: 988,
  gammad: 989,
  gap: 10886,
  Gbreve: 286,
  gbreve: 287,
  Gcedil: 290,
  Gcirc: 284,
  gcirc: 285,
  Gcy: 1043,
  gcy: 1075,
  Gdot: 288,
  gdot: 289,
  ge: 8805,
  gE: 8807,
  gEl: 10892,
  gel: 8923,
  geq: 8805,
  geqq: 8807,
  geqslant: 10878,
  gescc: 10921,
  ges: 10878,
  gesdot: 10880,
  gesdoto: 10882,
  gesdotol: 10884,
  gesl: 8923,
  gesles: 10900,
  Gfr: 55349,
  gfr: 55349,
  gg: 8811,
  Gg: 8921,
  ggg: 8921,
  gimel: 8503,
  GJcy: 1027,
  gjcy: 1107,
  gla: 10917,
  gl: 8823,
  glE: 10898,
  glj: 10916,
  gnap: 10890,
  gnapprox: 10890,
  gne: 10888,
  gnE: 8809,
  gneq: 10888,
  gneqq: 8809,
  gnsim: 8935,
  Gopf: 55349,
  gopf: 55349,
  grave: 96,
  GreaterEqual: 8805,
  GreaterEqualLess: 8923,
  GreaterFullEqual: 8807,
  GreaterGreater: 10914,
  GreaterLess: 8823,
  GreaterSlantEqual: 10878,
  GreaterTilde: 8819,
  Gscr: 55349,
  gscr: 8458,
  gsim: 8819,
  gsime: 10894,
  gsiml: 10896,
  gtcc: 10919,
  gtcir: 10874,
  gt: 62,
  GT: 62,
  Gt: 8811,
  gtdot: 8919,
  gtlPar: 10645,
  gtquest: 10876,
  gtrapprox: 10886,
  gtrarr: 10616,
  gtrdot: 8919,
  gtreqless: 8923,
  gtreqqless: 10892,
  gtrless: 8823,
  gtrsim: 8819,
  gvertneqq: 8809,
  gvnE: 8809,
  Hacek: 711,
  hairsp: 8202,
  half: 189,
  hamilt: 8459,
  HARDcy: 1066,
  hardcy: 1098,
  harrcir: 10568,
  harr: 8596,
  hArr: 8660,
  harrw: 8621,
  Hat: 94,
  hbar: 8463,
  Hcirc: 292,
  hcirc: 293,
  hearts: 9829,
  heartsuit: 9829,
  hellip: 8230,
  hercon: 8889,
  hfr: 55349,
  Hfr: 8460,
  HilbertSpace: 8459,
  hksearow: 10533,
  hkswarow: 10534,
  hoarr: 8703,
  homtht: 8763,
  hookleftarrow: 8617,
  hookrightarrow: 8618,
  hopf: 55349,
  Hopf: 8461,
  horbar: 8213,
  HorizontalLine: 9472,
  hscr: 55349,
  Hscr: 8459,
  hslash: 8463,
  Hstrok: 294,
  hstrok: 295,
  HumpDownHump: 8782,
  HumpEqual: 8783,
  hybull: 8259,
  hyphen: 8208,
  Iacute: 205,
  iacute: 237,
  ic: 8291,
  Icirc: 206,
  icirc: 238,
  Icy: 1048,
  icy: 1080,
  Idot: 304,
  IEcy: 1045,
  iecy: 1077,
  iexcl: 161,
  iff: 8660,
  ifr: 55349,
  Ifr: 8465,
  Igrave: 204,
  igrave: 236,
  ii: 8520,
  iiiint: 10764,
  iiint: 8749,
  iinfin: 10716,
  iiota: 8489,
  IJlig: 306,
  ijlig: 307,
  Imacr: 298,
  imacr: 299,
  image: 8465,
  ImaginaryI: 8520,
  imagline: 8464,
  imagpart: 8465,
  imath: 305,
  Im: 8465,
  imof: 8887,
  imped: 437,
  Implies: 8658,
  incare: 8453,
  'in': 8712,
  infin: 8734,
  infintie: 10717,
  inodot: 305,
  intcal: 8890,
  int: 8747,
  Int: 8748,
  integers: 8484,
  Integral: 8747,
  intercal: 8890,
  Intersection: 8898,
  intlarhk: 10775,
  intprod: 10812,
  InvisibleComma: 8291,
  InvisibleTimes: 8290,
  IOcy: 1025,
  iocy: 1105,
  Iogon: 302,
  iogon: 303,
  Iopf: 55349,
  iopf: 55349,
  Iota: 921,
  iota: 953,
  iprod: 10812,
  iquest: 191,
  iscr: 55349,
  Iscr: 8464,
  isin: 8712,
  isindot: 8949,
  isinE: 8953,
  isins: 8948,
  isinsv: 8947,
  isinv: 8712,
  it: 8290,
  Itilde: 296,
  itilde: 297,
  Iukcy: 1030,
  iukcy: 1110,
  Iuml: 207,
  iuml: 239,
  Jcirc: 308,
  jcirc: 309,
  Jcy: 1049,
  jcy: 1081,
  Jfr: 55349,
  jfr: 55349,
  jmath: 567,
  Jopf: 55349,
  jopf: 55349,
  Jscr: 55349,
  jscr: 55349,
  Jsercy: 1032,
  jsercy: 1112,
  Jukcy: 1028,
  jukcy: 1108,
  Kappa: 922,
  kappa: 954,
  kappav: 1008,
  Kcedil: 310,
  kcedil: 311,
  Kcy: 1050,
  kcy: 1082,
  Kfr: 55349,
  kfr: 55349,
  kgreen: 312,
  KHcy: 1061,
  khcy: 1093,
  KJcy: 1036,
  kjcy: 1116,
  Kopf: 55349,
  kopf: 55349,
  Kscr: 55349,
  kscr: 55349,
  lAarr: 8666,
  Lacute: 313,
  lacute: 314,
  laemptyv: 10676,
  lagran: 8466,
  Lambda: 923,
  lambda: 955,
  lang: 10216,
  Lang: 10218,
  langd: 10641,
  langle: 10216,
  lap: 10885,
  Laplacetrf: 8466,
  laquo: 171,
  larrb: 8676,
  larrbfs: 10527,
  larr: 8592,
  Larr: 8606,
  lArr: 8656,
  larrfs: 10525,
  larrhk: 8617,
  larrlp: 8619,
  larrpl: 10553,
  larrsim: 10611,
  larrtl: 8610,
  latail: 10521,
  lAtail: 10523,
  lat: 10923,
  late: 10925,
  lates: 10925,
  lbarr: 10508,
  lBarr: 10510,
  lbbrk: 10098,
  lbrace: 123,
  lbrack: 91,
  lbrke: 10635,
  lbrksld: 10639,
  lbrkslu: 10637,
  Lcaron: 317,
  lcaron: 318,
  Lcedil: 315,
  lcedil: 316,
  lceil: 8968,
  lcub: 123,
  Lcy: 1051,
  lcy: 1083,
  ldca: 10550,
  ldquo: 8220,
  ldquor: 8222,
  ldrdhar: 10599,
  ldrushar: 10571,
  ldsh: 8626,
  le: 8804,
  lE: 8806,
  LeftAngleBracket: 10216,
  LeftArrowBar: 8676,
  leftarrow: 8592,
  LeftArrow: 8592,
  Leftarrow: 8656,
  LeftArrowRightArrow: 8646,
  leftarrowtail: 8610,
  LeftCeiling: 8968,
  LeftDoubleBracket: 10214,
  LeftDownTeeVector: 10593,
  LeftDownVectorBar: 10585,
  LeftDownVector: 8643,
  LeftFloor: 8970,
  leftharpoondown: 8637,
  leftharpoonup: 8636,
  leftleftarrows: 8647,
  leftrightarrow: 8596,
  LeftRightArrow: 8596,
  Leftrightarrow: 8660,
  leftrightarrows: 8646,
  leftrightharpoons: 8651,
  leftrightsquigarrow: 8621,
  LeftRightVector: 10574,
  LeftTeeArrow: 8612,
  LeftTee: 8867,
  LeftTeeVector: 10586,
  leftthreetimes: 8907,
  LeftTriangleBar: 10703,
  LeftTriangle: 8882,
  LeftTriangleEqual: 8884,
  LeftUpDownVector: 10577,
  LeftUpTeeVector: 10592,
  LeftUpVectorBar: 10584,
  LeftUpVector: 8639,
  LeftVectorBar: 10578,
  LeftVector: 8636,
  lEg: 10891,
  leg: 8922,
  leq: 8804,
  leqq: 8806,
  leqslant: 10877,
  lescc: 10920,
  les: 10877,
  lesdot: 10879,
  lesdoto: 10881,
  lesdotor: 10883,
  lesg: 8922,
  lesges: 10899,
  lessapprox: 10885,
  lessdot: 8918,
  lesseqgtr: 8922,
  lesseqqgtr: 10891,
  LessEqualGreater: 8922,
  LessFullEqual: 8806,
  LessGreater: 8822,
  lessgtr: 8822,
  LessLess: 10913,
  lesssim: 8818,
  LessSlantEqual: 10877,
  LessTilde: 8818,
  lfisht: 10620,
  lfloor: 8970,
  Lfr: 55349,
  lfr: 55349,
  lg: 8822,
  lgE: 10897,
  lHar: 10594,
  lhard: 8637,
  lharu: 8636,
  lharul: 10602,
  lhblk: 9604,
  LJcy: 1033,
  ljcy: 1113,
  llarr: 8647,
  ll: 8810,
  Ll: 8920,
  llcorner: 8990,
  Lleftarrow: 8666,
  llhard: 10603,
  lltri: 9722,
  Lmidot: 319,
  lmidot: 320,
  lmoustache: 9136,
  lmoust: 9136,
  lnap: 10889,
  lnapprox: 10889,
  lne: 10887,
  lnE: 8808,
  lneq: 10887,
  lneqq: 8808,
  lnsim: 8934,
  loang: 10220,
  loarr: 8701,
  lobrk: 10214,
  longleftarrow: 10229,
  LongLeftArrow: 10229,
  Longleftarrow: 10232,
  longleftrightarrow: 10231,
  LongLeftRightArrow: 10231,
  Longleftrightarrow: 10234,
  longmapsto: 10236,
  longrightarrow: 10230,
  LongRightArrow: 10230,
  Longrightarrow: 10233,
  looparrowleft: 8619,
  looparrowright: 8620,
  lopar: 10629,
  Lopf: 55349,
  lopf: 55349,
  loplus: 10797,
  lotimes: 10804,
  lowast: 8727,
  lowbar: 95,
  LowerLeftArrow: 8601,
  LowerRightArrow: 8600,
  loz: 9674,
  lozenge: 9674,
  lozf: 10731,
  lpar: 40,
  lparlt: 10643,
  lrarr: 8646,
  lrcorner: 8991,
  lrhar: 8651,
  lrhard: 10605,
  lrm: 8206,
  lrtri: 8895,
  lsaquo: 8249,
  lscr: 55349,
  Lscr: 8466,
  lsh: 8624,
  Lsh: 8624,
  lsim: 8818,
  lsime: 10893,
  lsimg: 10895,
  lsqb: 91,
  lsquo: 8216,
  lsquor: 8218,
  Lstrok: 321,
  lstrok: 322,
  ltcc: 10918,
  ltcir: 10873,
  lt: 60,
  LT: 60,
  Lt: 8810,
  ltdot: 8918,
  lthree: 8907,
  ltimes: 8905,
  ltlarr: 10614,
  ltquest: 10875,
  ltri: 9667,
  ltrie: 8884,
  ltrif: 9666,
  ltrPar: 10646,
  lurdshar: 10570,
  luruhar: 10598,
  lvertneqq: 8808,
  lvnE: 8808,
  macr: 175,
  male: 9794,
  malt: 10016,
  maltese: 10016,
  Map: 10501,
  map: 8614,
  mapsto: 8614,
  mapstodown: 8615,
  mapstoleft: 8612,
  mapstoup: 8613,
  marker: 9646,
  mcomma: 10793,
  Mcy: 1052,
  mcy: 1084,
  mdash: 8212,
  mDDot: 8762,
  measuredangle: 8737,
  MediumSpace: 8287,
  Mellintrf: 8499,
  Mfr: 55349,
  mfr: 55349,
  mho: 8487,
  micro: 181,
  midast: 42,
  midcir: 10992,
  mid: 8739,
  middot: 183,
  minusb: 8863,
  minus: 8722,
  minusd: 8760,
  minusdu: 10794,
  MinusPlus: 8723,
  mlcp: 10971,
  mldr: 8230,
  mnplus: 8723,
  models: 8871,
  Mopf: 55349,
  mopf: 55349,
  mp: 8723,
  mscr: 55349,
  Mscr: 8499,
  mstpos: 8766,
  Mu: 924,
  mu: 956,
  multimap: 8888,
  mumap: 8888,
  nabla: 8711,
  Nacute: 323,
  nacute: 324,
  nang: 8736,
  nap: 8777,
  napE: 10864,
  napid: 8779,
  napos: 329,
  napprox: 8777,
  natural: 9838,
  naturals: 8469,
  natur: 9838,
  nbsp: 160,
  nbump: 8782,
  nbumpe: 8783,
  ncap: 10819,
  Ncaron: 327,
  ncaron: 328,
  Ncedil: 325,
  ncedil: 326,
  ncong: 8775,
  ncongdot: 10861,
  ncup: 10818,
  Ncy: 1053,
  ncy: 1085,
  ndash: 8211,
  nearhk: 10532,
  nearr: 8599,
  neArr: 8663,
  nearrow: 8599,
  ne: 8800,
  nedot: 8784,
  NegativeMediumSpace: 8203,
  NegativeThickSpace: 8203,
  NegativeThinSpace: 8203,
  NegativeVeryThinSpace: 8203,
  nequiv: 8802,
  nesear: 10536,
  nesim: 8770,
  NestedGreaterGreater: 8811,
  NestedLessLess: 8810,
  NewLine: 10,
  nexist: 8708,
  nexists: 8708,
  Nfr: 55349,
  nfr: 55349,
  ngE: 8807,
  nge: 8817,
  ngeq: 8817,
  ngeqq: 8807,
  ngeqslant: 10878,
  nges: 10878,
  nGg: 8921,
  ngsim: 8821,
  nGt: 8811,
  ngt: 8815,
  ngtr: 8815,
  nGtv: 8811,
  nharr: 8622,
  nhArr: 8654,
  nhpar: 10994,
  ni: 8715,
  nis: 8956,
  nisd: 8954,
  niv: 8715,
  NJcy: 1034,
  njcy: 1114,
  nlarr: 8602,
  nlArr: 8653,
  nldr: 8229,
  nlE: 8806,
  nle: 8816,
  nleftarrow: 8602,
  nLeftarrow: 8653,
  nleftrightarrow: 8622,
  nLeftrightarrow: 8654,
  nleq: 8816,
  nleqq: 8806,
  nleqslant: 10877,
  nles: 10877,
  nless: 8814,
  nLl: 8920,
  nlsim: 8820,
  nLt: 8810,
  nlt: 8814,
  nltri: 8938,
  nltrie: 8940,
  nLtv: 8810,
  nmid: 8740,
  NoBreak: 8288,
  NonBreakingSpace: 160,
  nopf: 55349,
  Nopf: 8469,
  Not: 10988,
  not: 172,
  NotCongruent: 8802,
  NotCupCap: 8813,
  NotDoubleVerticalBar: 8742,
  NotElement: 8713,
  NotEqual: 8800,
  NotEqualTilde: 8770,
  NotExists: 8708,
  NotGreater: 8815,
  NotGreaterEqual: 8817,
  NotGreaterFullEqual: 8807,
  NotGreaterGreater: 8811,
  NotGreaterLess: 8825,
  NotGreaterSlantEqual: 10878,
  NotGreaterTilde: 8821,
  NotHumpDownHump: 8782,
  NotHumpEqual: 8783,
  notin: 8713,
  notindot: 8949,
  notinE: 8953,
  notinva: 8713,
  notinvb: 8951,
  notinvc: 8950,
  NotLeftTriangleBar: 10703,
  NotLeftTriangle: 8938,
  NotLeftTriangleEqual: 8940,
  NotLess: 8814,
  NotLessEqual: 8816,
  NotLessGreater: 8824,
  NotLessLess: 8810,
  NotLessSlantEqual: 10877,
  NotLessTilde: 8820,
  NotNestedGreaterGreater: 10914,
  NotNestedLessLess: 10913,
  notni: 8716,
  notniva: 8716,
  notnivb: 8958,
  notnivc: 8957,
  NotPrecedes: 8832,
  NotPrecedesEqual: 10927,
  NotPrecedesSlantEqual: 8928,
  NotReverseElement: 8716,
  NotRightTriangleBar: 10704,
  NotRightTriangle: 8939,
  NotRightTriangleEqual: 8941,
  NotSquareSubset: 8847,
  NotSquareSubsetEqual: 8930,
  NotSquareSuperset: 8848,
  NotSquareSupersetEqual: 8931,
  NotSubset: 8834,
  NotSubsetEqual: 8840,
  NotSucceeds: 8833,
  NotSucceedsEqual: 10928,
  NotSucceedsSlantEqual: 8929,
  NotSucceedsTilde: 8831,
  NotSuperset: 8835,
  NotSupersetEqual: 8841,
  NotTilde: 8769,
  NotTildeEqual: 8772,
  NotTildeFullEqual: 8775,
  NotTildeTilde: 8777,
  NotVerticalBar: 8740,
  nparallel: 8742,
  npar: 8742,
  nparsl: 11005,
  npart: 8706,
  npolint: 10772,
  npr: 8832,
  nprcue: 8928,
  nprec: 8832,
  npreceq: 10927,
  npre: 10927,
  nrarrc: 10547,
  nrarr: 8603,
  nrArr: 8655,
  nrarrw: 8605,
  nrightarrow: 8603,
  nRightarrow: 8655,
  nrtri: 8939,
  nrtrie: 8941,
  nsc: 8833,
  nsccue: 8929,
  nsce: 10928,
  Nscr: 55349,
  nscr: 55349,
  nshortmid: 8740,
  nshortparallel: 8742,
  nsim: 8769,
  nsime: 8772,
  nsimeq: 8772,
  nsmid: 8740,
  nspar: 8742,
  nsqsube: 8930,
  nsqsupe: 8931,
  nsub: 8836,
  nsubE: 10949,
  nsube: 8840,
  nsubset: 8834,
  nsubseteq: 8840,
  nsubseteqq: 10949,
  nsucc: 8833,
  nsucceq: 10928,
  nsup: 8837,
  nsupE: 10950,
  nsupe: 8841,
  nsupset: 8835,
  nsupseteq: 8841,
  nsupseteqq: 10950,
  ntgl: 8825,
  Ntilde: 209,
  ntilde: 241,
  ntlg: 8824,
  ntriangleleft: 8938,
  ntrianglelefteq: 8940,
  ntriangleright: 8939,
  ntrianglerighteq: 8941,
  Nu: 925,
  nu: 957,
  num: 35,
  numero: 8470,
  numsp: 8199,
  nvap: 8781,
  nvdash: 8876,
  nvDash: 8877,
  nVdash: 8878,
  nVDash: 8879,
  nvge: 8805,
  nvgt: 62,
  nvHarr: 10500,
  nvinfin: 10718,
  nvlArr: 10498,
  nvle: 8804,
  nvlt: 62,
  nvltrie: 8884,
  nvrArr: 10499,
  nvrtrie: 8885,
  nvsim: 8764,
  nwarhk: 10531,
  nwarr: 8598,
  nwArr: 8662,
  nwarrow: 8598,
  nwnear: 10535,
  Oacute: 211,
  oacute: 243,
  oast: 8859,
  Ocirc: 212,
  ocirc: 244,
  ocir: 8858,
  Ocy: 1054,
  ocy: 1086,
  odash: 8861,
  Odblac: 336,
  odblac: 337,
  odiv: 10808,
  odot: 8857,
  odsold: 10684,
  OElig: 338,
  oelig: 339,
  ofcir: 10687,
  Ofr: 55349,
  ofr: 55349,
  ogon: 731,
  Ograve: 210,
  ograve: 242,
  ogt: 10689,
  ohbar: 10677,
  ohm: 937,
  oint: 8750,
  olarr: 8634,
  olcir: 10686,
  olcross: 10683,
  oline: 8254,
  olt: 10688,
  Omacr: 332,
  omacr: 333,
  Omega: 937,
  omega: 969,
  Omicron: 927,
  omicron: 959,
  omid: 10678,
  ominus: 8854,
  Oopf: 55349,
  oopf: 55349,
  opar: 10679,
  OpenCurlyDoubleQuote: 8220,
  OpenCurlyQuote: 8216,
  operp: 10681,
  oplus: 8853,
  orarr: 8635,
  Or: 10836,
  or: 8744,
  ord: 10845,
  order: 8500,
  orderof: 8500,
  ordf: 170,
  ordm: 186,
  origof: 8886,
  oror: 10838,
  orslope: 10839,
  orv: 10843,
  oS: 9416,
  Oscr: 55349,
  oscr: 8500,
  Oslash: 216,
  oslash: 248,
  osol: 8856,
  Otilde: 213,
  otilde: 245,
  otimesas: 10806,
  Otimes: 10807,
  otimes: 8855,
  Ouml: 214,
  ouml: 246,
  ovbar: 9021,
  OverBar: 8254,
  OverBrace: 9182,
  OverBracket: 9140,
  OverParenthesis: 9180,
  para: 182,
  parallel: 8741,
  par: 8741,
  parsim: 10995,
  parsl: 11005,
  part: 8706,
  PartialD: 8706,
  Pcy: 1055,
  pcy: 1087,
  percnt: 37,
  period: 46,
  permil: 8240,
  perp: 8869,
  pertenk: 8241,
  Pfr: 55349,
  pfr: 55349,
  Phi: 934,
  phi: 966,
  phiv: 981,
  phmmat: 8499,
  phone: 9742,
  Pi: 928,
  pi: 960,
  pitchfork: 8916,
  piv: 982,
  planck: 8463,
  planckh: 8462,
  plankv: 8463,
  plusacir: 10787,
  plusb: 8862,
  pluscir: 10786,
  plus: 43,
  plusdo: 8724,
  plusdu: 10789,
  pluse: 10866,
  PlusMinus: 177,
  plusmn: 177,
  plussim: 10790,
  plustwo: 10791,
  pm: 177,
  Poincareplane: 8460,
  pointint: 10773,
  popf: 55349,
  Popf: 8473,
  pound: 163,
  prap: 10935,
  Pr: 10939,
  pr: 8826,
  prcue: 8828,
  precapprox: 10935,
  prec: 8826,
  preccurlyeq: 8828,
  Precedes: 8826,
  PrecedesEqual: 10927,
  PrecedesSlantEqual: 8828,
  PrecedesTilde: 8830,
  preceq: 10927,
  precnapprox: 10937,
  precneqq: 10933,
  precnsim: 8936,
  pre: 10927,
  prE: 10931,
  precsim: 8830,
  prime: 8242,
  Prime: 8243,
  primes: 8473,
  prnap: 10937,
  prnE: 10933,
  prnsim: 8936,
  prod: 8719,
  Product: 8719,
  profalar: 9006,
  profline: 8978,
  profsurf: 8979,
  prop: 8733,
  Proportional: 8733,
  Proportion: 8759,
  propto: 8733,
  prsim: 8830,
  prurel: 8880,
  Pscr: 55349,
  pscr: 55349,
  Psi: 936,
  psi: 968,
  puncsp: 8200,
  Qfr: 55349,
  qfr: 55349,
  qint: 10764,
  qopf: 55349,
  Qopf: 8474,
  qprime: 8279,
  Qscr: 55349,
  qscr: 55349,
  quaternions: 8461,
  quatint: 10774,
  quest: 63,
  questeq: 8799,
  quot: 34,
  QUOT: 34,
  rAarr: 8667,
  race: 8765,
  Racute: 340,
  racute: 341,
  radic: 8730,
  raemptyv: 10675,
  rang: 10217,
  Rang: 10219,
  rangd: 10642,
  range: 10661,
  rangle: 10217,
  raquo: 187,
  rarrap: 10613,
  rarrb: 8677,
  rarrbfs: 10528,
  rarrc: 10547,
  rarr: 8594,
  Rarr: 8608,
  rArr: 8658,
  rarrfs: 10526,
  rarrhk: 8618,
  rarrlp: 8620,
  rarrpl: 10565,
  rarrsim: 10612,
  Rarrtl: 10518,
  rarrtl: 8611,
  rarrw: 8605,
  ratail: 10522,
  rAtail: 10524,
  ratio: 8758,
  rationals: 8474,
  rbarr: 10509,
  rBarr: 10511,
  RBarr: 10512,
  rbbrk: 10099,
  rbrace: 125,
  rbrack: 93,
  rbrke: 10636,
  rbrksld: 10638,
  rbrkslu: 10640,
  Rcaron: 344,
  rcaron: 345,
  Rcedil: 342,
  rcedil: 343,
  rceil: 8969,
  rcub: 125,
  Rcy: 1056,
  rcy: 1088,
  rdca: 10551,
  rdldhar: 10601,
  rdquo: 8221,
  rdquor: 8221,
  rdsh: 8627,
  real: 8476,
  realine: 8475,
  realpart: 8476,
  reals: 8477,
  Re: 8476,
  rect: 9645,
  reg: 174,
  REG: 174,
  ReverseElement: 8715,
  ReverseEquilibrium: 8651,
  ReverseUpEquilibrium: 10607,
  rfisht: 10621,
  rfloor: 8971,
  rfr: 55349,
  Rfr: 8476,
  rHar: 10596,
  rhard: 8641,
  rharu: 8640,
  rharul: 10604,
  Rho: 929,
  rho: 961,
  rhov: 1009,
  RightAngleBracket: 10217,
  RightArrowBar: 8677,
  rightarrow: 8594,
  RightArrow: 8594,
  Rightarrow: 8658,
  RightArrowLeftArrow: 8644,
  rightarrowtail: 8611,
  RightCeiling: 8969,
  RightDoubleBracket: 10215,
  RightDownTeeVector: 10589,
  RightDownVectorBar: 10581,
  RightDownVector: 8642,
  RightFloor: 8971,
  rightharpoondown: 8641,
  rightharpoonup: 8640,
  rightleftarrows: 8644,
  rightleftharpoons: 8652,
  rightrightarrows: 8649,
  rightsquigarrow: 8605,
  RightTeeArrow: 8614,
  RightTee: 8866,
  RightTeeVector: 10587,
  rightthreetimes: 8908,
  RightTriangleBar: 10704,
  RightTriangle: 8883,
  RightTriangleEqual: 8885,
  RightUpDownVector: 10575,
  RightUpTeeVector: 10588,
  RightUpVectorBar: 10580,
  RightUpVector: 8638,
  RightVectorBar: 10579,
  RightVector: 8640,
  ring: 730,
  risingdotseq: 8787,
  rlarr: 8644,
  rlhar: 8652,
  rlm: 8207,
  rmoustache: 9137,
  rmoust: 9137,
  rnmid: 10990,
  roang: 10221,
  roarr: 8702,
  robrk: 10215,
  ropar: 10630,
  ropf: 55349,
  Ropf: 8477,
  roplus: 10798,
  rotimes: 10805,
  RoundImplies: 10608,
  rpar: 41,
  rpargt: 10644,
  rppolint: 10770,
  rrarr: 8649,
  Rrightarrow: 8667,
  rsaquo: 8250,
  rscr: 55349,
  Rscr: 8475,
  rsh: 8625,
  Rsh: 8625,
  rsqb: 93,
  rsquo: 8217,
  rsquor: 8217,
  rthree: 8908,
  rtimes: 8906,
  rtri: 9657,
  rtrie: 8885,
  rtrif: 9656,
  rtriltri: 10702,
  RuleDelayed: 10740,
  ruluhar: 10600,
  rx: 8478,
  Sacute: 346,
  sacute: 347,
  sbquo: 8218,
  scap: 10936,
  Scaron: 352,
  scaron: 353,
  Sc: 10940,
  sc: 8827,
  sccue: 8829,
  sce: 10928,
  scE: 10932,
  Scedil: 350,
  scedil: 351,
  Scirc: 348,
  scirc: 349,
  scnap: 10938,
  scnE: 10934,
  scnsim: 8937,
  scpolint: 10771,
  scsim: 8831,
  Scy: 1057,
  scy: 1089,
  sdotb: 8865,
  sdot: 8901,
  sdote: 10854,
  searhk: 10533,
  searr: 8600,
  seArr: 8664,
  searrow: 8600,
  sect: 167,
  semi: 59,
  seswar: 10537,
  setminus: 8726,
  setmn: 8726,
  sext: 10038,
  Sfr: 55349,
  sfr: 55349,
  sfrown: 8994,
  sharp: 9839,
  SHCHcy: 1065,
  shchcy: 1097,
  SHcy: 1064,
  shcy: 1096,
  ShortDownArrow: 8595,
  ShortLeftArrow: 8592,
  shortmid: 8739,
  shortparallel: 8741,
  ShortRightArrow: 8594,
  ShortUpArrow: 8593,
  shy: 173,
  Sigma: 931,
  sigma: 963,
  sigmaf: 962,
  sigmav: 962,
  sim: 8764,
  simdot: 10858,
  sime: 8771,
  simeq: 8771,
  simg: 10910,
  simgE: 10912,
  siml: 10909,
  simlE: 10911,
  simne: 8774,
  simplus: 10788,
  simrarr: 10610,
  slarr: 8592,
  SmallCircle: 8728,
  smallsetminus: 8726,
  smashp: 10803,
  smeparsl: 10724,
  smid: 8739,
  smile: 8995,
  smt: 10922,
  smte: 10924,
  smtes: 10924,
  SOFTcy: 1068,
  softcy: 1100,
  solbar: 9023,
  solb: 10692,
  sol: 47,
  Sopf: 55349,
  sopf: 55349,
  spades: 9824,
  spadesuit: 9824,
  spar: 8741,
  sqcap: 8851,
  sqcaps: 8851,
  sqcup: 8852,
  sqcups: 8852,
  Sqrt: 8730,
  sqsub: 8847,
  sqsube: 8849,
  sqsubset: 8847,
  sqsubseteq: 8849,
  sqsup: 8848,
  sqsupe: 8850,
  sqsupset: 8848,
  sqsupseteq: 8850,
  square: 9633,
  Square: 9633,
  SquareIntersection: 8851,
  SquareSubset: 8847,
  SquareSubsetEqual: 8849,
  SquareSuperset: 8848,
  SquareSupersetEqual: 8850,
  SquareUnion: 8852,
  squarf: 9642,
  squ: 9633,
  squf: 9642,
  srarr: 8594,
  Sscr: 55349,
  sscr: 55349,
  ssetmn: 8726,
  ssmile: 8995,
  sstarf: 8902,
  Star: 8902,
  star: 9734,
  starf: 9733,
  straightepsilon: 1013,
  straightphi: 981,
  strns: 175,
  sub: 8834,
  Sub: 8912,
  subdot: 10941,
  subE: 10949,
  sube: 8838,
  subedot: 10947,
  submult: 10945,
  subnE: 10955,
  subne: 8842,
  subplus: 10943,
  subrarr: 10617,
  subset: 8834,
  Subset: 8912,
  subseteq: 8838,
  subseteqq: 10949,
  SubsetEqual: 8838,
  subsetneq: 8842,
  subsetneqq: 10955,
  subsim: 10951,
  subsub: 10965,
  subsup: 10963,
  succapprox: 10936,
  succ: 8827,
  succcurlyeq: 8829,
  Succeeds: 8827,
  SucceedsEqual: 10928,
  SucceedsSlantEqual: 8829,
  SucceedsTilde: 8831,
  succeq: 10928,
  succnapprox: 10938,
  succneqq: 10934,
  succnsim: 8937,
  succsim: 8831,
  SuchThat: 8715,
  sum: 8721,
  Sum: 8721,
  sung: 9834,
  sup1: 185,
  sup2: 178,
  sup3: 179,
  sup: 8835,
  Sup: 8913,
  supdot: 10942,
  supdsub: 10968,
  supE: 10950,
  supe: 8839,
  supedot: 10948,
  Superset: 8835,
  SupersetEqual: 8839,
  suphsol: 10185,
  suphsub: 10967,
  suplarr: 10619,
  supmult: 10946,
  supnE: 10956,
  supne: 8843,
  supplus: 10944,
  supset: 8835,
  Supset: 8913,
  supseteq: 8839,
  supseteqq: 10950,
  supsetneq: 8843,
  supsetneqq: 10956,
  supsim: 10952,
  supsub: 10964,
  supsup: 10966,
  swarhk: 10534,
  swarr: 8601,
  swArr: 8665,
  swarrow: 8601,
  swnwar: 10538,
  szlig: 223,
  Tab: NaN,
  target: 8982,
  Tau: 932,
  tau: 964,
  tbrk: 9140,
  Tcaron: 356,
  tcaron: 357,
  Tcedil: 354,
  tcedil: 355,
  Tcy: 1058,
  tcy: 1090,
  tdot: 8411,
  telrec: 8981,
  Tfr: 55349,
  tfr: 55349,
  there4: 8756,
  therefore: 8756,
  Therefore: 8756,
  Theta: 920,
  theta: 952,
  thetasym: 977,
  thetav: 977,
  thickapprox: 8776,
  thicksim: 8764,
  ThickSpace: 8287,
  ThinSpace: 8201,
  thinsp: 8201,
  thkap: 8776,
  thksim: 8764,
  THORN: 222,
  thorn: 254,
  tilde: 732,
  Tilde: 8764,
  TildeEqual: 8771,
  TildeFullEqual: 8773,
  TildeTilde: 8776,
  timesbar: 10801,
  timesb: 8864,
  times: 215,
  timesd: 10800,
  tint: 8749,
  toea: 10536,
  topbot: 9014,
  topcir: 10993,
  top: 8868,
  Topf: 55349,
  topf: 55349,
  topfork: 10970,
  tosa: 10537,
  tprime: 8244,
  trade: 8482,
  TRADE: 8482,
  triangle: 9653,
  triangledown: 9663,
  triangleleft: 9667,
  trianglelefteq: 8884,
  triangleq: 8796,
  triangleright: 9657,
  trianglerighteq: 8885,
  tridot: 9708,
  trie: 8796,
  triminus: 10810,
  TripleDot: 8411,
  triplus: 10809,
  trisb: 10701,
  tritime: 10811,
  trpezium: 9186,
  Tscr: 55349,
  tscr: 55349,
  TScy: 1062,
  tscy: 1094,
  TSHcy: 1035,
  tshcy: 1115,
  Tstrok: 358,
  tstrok: 359,
  twixt: 8812,
  twoheadleftarrow: 8606,
  twoheadrightarrow: 8608,
  Uacute: 218,
  uacute: 250,
  uarr: 8593,
  Uarr: 8607,
  uArr: 8657,
  Uarrocir: 10569,
  Ubrcy: 1038,
  ubrcy: 1118,
  Ubreve: 364,
  ubreve: 365,
  Ucirc: 219,
  ucirc: 251,
  Ucy: 1059,
  ucy: 1091,
  udarr: 8645,
  Udblac: 368,
  udblac: 369,
  udhar: 10606,
  ufisht: 10622,
  Ufr: 55349,
  ufr: 55349,
  Ugrave: 217,
  ugrave: 249,
  uHar: 10595,
  uharl: 8639,
  uharr: 8638,
  uhblk: 9600,
  ulcorn: 8988,
  ulcorner: 8988,
  ulcrop: 8975,
  ultri: 9720,
  Umacr: 362,
  umacr: 363,
  uml: 168,
  UnderBar: 95,
  UnderBrace: 9183,
  UnderBracket: 9141,
  UnderParenthesis: 9181,
  Union: 8899,
  UnionPlus: 8846,
  Uogon: 370,
  uogon: 371,
  Uopf: 55349,
  uopf: 55349,
  UpArrowBar: 10514,
  uparrow: 8593,
  UpArrow: 8593,
  Uparrow: 8657,
  UpArrowDownArrow: 8645,
  updownarrow: 8597,
  UpDownArrow: 8597,
  Updownarrow: 8661,
  UpEquilibrium: 10606,
  upharpoonleft: 8639,
  upharpoonright: 8638,
  uplus: 8846,
  UpperLeftArrow: 8598,
  UpperRightArrow: 8599,
  upsi: 965,
  Upsi: 978,
  upsih: 978,
  Upsilon: 933,
  upsilon: 965,
  UpTeeArrow: 8613,
  UpTee: 8869,
  upuparrows: 8648,
  urcorn: 8989,
  urcorner: 8989,
  urcrop: 8974,
  Uring: 366,
  uring: 367,
  urtri: 9721,
  Uscr: 55349,
  uscr: 55349,
  utdot: 8944,
  Utilde: 360,
  utilde: 361,
  utri: 9653,
  utrif: 9652,
  uuarr: 8648,
  Uuml: 220,
  uuml: 252,
  uwangle: 10663,
  vangrt: 10652,
  varepsilon: 1013,
  varkappa: 1008,
  varnothing: 8709,
  varphi: 981,
  varpi: 982,
  varpropto: 8733,
  varr: 8597,
  vArr: 8661,
  varrho: 1009,
  varsigma: 962,
  varsubsetneq: 8842,
  varsubsetneqq: 10955,
  varsupsetneq: 8843,
  varsupsetneqq: 10956,
  vartheta: 977,
  vartriangleleft: 8882,
  vartriangleright: 8883,
  vBar: 10984,
  Vbar: 10987,
  vBarv: 10985,
  Vcy: 1042,
  vcy: 1074,
  vdash: 8866,
  vDash: 8872,
  Vdash: 8873,
  VDash: 8875,
  Vdashl: 10982,
  veebar: 8891,
  vee: 8744,
  Vee: 8897,
  veeeq: 8794,
  vellip: 8942,
  verbar: 124,
  Verbar: 8214,
  vert: 124,
  Vert: 8214,
  VerticalBar: 8739,
  VerticalLine: 124,
  VerticalSeparator: 10072,
  VerticalTilde: 8768,
  VeryThinSpace: 8202,
  Vfr: 55349,
  vfr: 55349,
  vltri: 8882,
  vnsub: 8834,
  vnsup: 8835,
  Vopf: 55349,
  vopf: 55349,
  vprop: 8733,
  vrtri: 8883,
  Vscr: 55349,
  vscr: 55349,
  vsubnE: 10955,
  vsubne: 8842,
  vsupnE: 10956,
  vsupne: 8843,
  Vvdash: 8874,
  vzigzag: 10650,
  Wcirc: 372,
  wcirc: 373,
  wedbar: 10847,
  wedge: 8743,
  Wedge: 8896,
  wedgeq: 8793,
  weierp: 8472,
  Wfr: 55349,
  wfr: 55349,
  Wopf: 55349,
  wopf: 55349,
  wp: 8472,
  wr: 8768,
  wreath: 8768,
  Wscr: 55349,
  wscr: 55349,
  xcap: 8898,
  xcirc: 9711,
  xcup: 8899,
  xdtri: 9661,
  Xfr: 55349,
  xfr: 55349,
  xharr: 10231,
  xhArr: 10234,
  Xi: 926,
  xi: 958,
  xlarr: 10229,
  xlArr: 10232,
  xmap: 10236,
  xnis: 8955,
  xodot: 10752,
  Xopf: 55349,
  xopf: 55349,
  xoplus: 10753,
  xotime: 10754,
  xrarr: 10230,
  xrArr: 10233,
  Xscr: 55349,
  xscr: 55349,
  xsqcup: 10758,
  xuplus: 10756,
  xutri: 9651,
  xvee: 8897,
  xwedge: 8896,
  Yacute: 221,
  yacute: 253,
  YAcy: 1071,
  yacy: 1103,
  Ycirc: 374,
  ycirc: 375,
  Ycy: 1067,
  ycy: 1099,
  yen: 165,
  Yfr: 55349,
  yfr: 55349,
  YIcy: 1031,
  yicy: 1111,
  Yopf: 55349,
  yopf: 55349,
  Yscr: 55349,
  yscr: 55349,
  YUcy: 1070,
  yucy: 1102,
  yuml: 255,
  Yuml: 376,
  Zacute: 377,
  zacute: 378,
  Zcaron: 381,
  zcaron: 382,
  Zcy: 1047,
  zcy: 1079,
  Zdot: 379,
  zdot: 380,
  zeetrf: 8488,
  ZeroWidthSpace: 8203,
  Zeta: 918,
  zeta: 950,
  zfr: 55349,
  Zfr: 8488,
  ZHcy: 1046,
  zhcy: 1078,
  zigrarr: 8669,
  zopf: 55349,
  Zopf: 8484,
  Zscr: 55349,
  zscr: 55349,
  zwj: 8205,
  zwnj: 8204 };

var entityToChar = function(m) {
    var isNumeric = /^&#/.test(m);
    var isHex = /^&#[Xx]/.test(m);
    var uchar;
    var ucode;
    if (isNumeric) {
        var num;
        if (isHex) {
            num = parseInt(m.slice(3, m.length - 1), 16);
        } else {
            num = parseInt(m.slice(2, m.length - 1), 10);
        }
        uchar = fromCodePoint(num);
    } else {
        ucode = entities[m.slice(1, m.length - 1)];
        if (ucode) {
            uchar = fromCodePoint(entities[m.slice(1, m.length - 1)]);
        }
    }
    return (uchar || m);
};

module.exports.entityToChar = entityToChar;

},{"./from-code-point":3}],6:[function(require,module,exports){
"use strict";

// commonmark.js - CommomMark in JavaScript
// Copyright (C) 2014 John MacFarlane
// License: BSD3.

// Basic usage:
//
// var commonmark = require('commonmark');
// var parser = new commonmark.Parser();
// var renderer = new commonmark.HtmlRenderer();
// console.log(renderer.render(parser.parse('Hello *world*')));

module.exports.Node = require('./node');
module.exports.Parser = require('./blocks');
module.exports.HtmlRenderer = require('./html');
module.exports.XmlRenderer = require('./xml');

},{"./blocks":1,"./html":4,"./node":8,"./xml":10}],7:[function(require,module,exports){
"use strict";

var Node = require('./node');
var common = require('./common');
var normalizeReference = require('./normalize-reference');

var normalizeURI = common.normalizeURI;
var unescapeString = common.unescapeString;
var fromCodePoint = require('./from-code-point.js');
var entityToChar = require('./html5-entities.js').entityToChar;

// Constants for character codes:

var C_NEWLINE = 10;
var C_ASTERISK = 42;
var C_UNDERSCORE = 95;
var C_BACKTICK = 96;
var C_OPEN_BRACKET = 91;
var C_CLOSE_BRACKET = 93;
var C_LESSTHAN = 60;
var C_BANG = 33;
var C_BACKSLASH = 92;
var C_AMPERSAND = 38;
var C_OPEN_PAREN = 40;
var C_COLON = 58;

// Some regexps used in inline parser:

var ESCAPABLE = '[!"#$%&\'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]';
var ESCAPED_CHAR = '\\\\' + ESCAPABLE;
var REG_CHAR = '[^\\\\()\\x00-\\x20]';
var IN_PARENS_NOSP = '\\((' + REG_CHAR + '|' + ESCAPED_CHAR + ')*\\)';
var TAGNAME = '[A-Za-z][A-Za-z0-9]*';
var ATTRIBUTENAME = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
var UNQUOTEDVALUE = "[^\"'=<>`\\x00-\\x20]+";
var SINGLEQUOTEDVALUE = "'[^']*'";
var DOUBLEQUOTEDVALUE = '"[^"]*"';
var ATTRIBUTEVALUE = "(?:" + UNQUOTEDVALUE + "|" + SINGLEQUOTEDVALUE + "|" + DOUBLEQUOTEDVALUE + ")";
var ATTRIBUTEVALUESPEC = "(?:" + "\\s*=" + "\\s*" + ATTRIBUTEVALUE + ")";
var ATTRIBUTE = "(?:" + "\\s+" + ATTRIBUTENAME + ATTRIBUTEVALUESPEC + "?)";
var OPENTAG = "<" + TAGNAME + ATTRIBUTE + "*" + "\\s*/?>";
var CLOSETAG = "</" + TAGNAME + "\\s*[>]";
var HTMLCOMMENT = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->";
var PROCESSINGINSTRUCTION = "[<][?].*?[?][>]";
var DECLARATION = "<![A-Z]+" + "\\s+[^>]*>";
var CDATA = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
var HTMLTAG = "(?:" + OPENTAG + "|" + CLOSETAG + "|" + HTMLCOMMENT + "|" +
        PROCESSINGINSTRUCTION + "|" + DECLARATION + "|" + CDATA + ")";
var ENTITY = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});";

var rePunctuation = new RegExp(/^[\u2000-\u206F\u2E00-\u2E7F\\'!"#\$%&\(\)\*\+,\-\.\/:;<=>\?@\[\]\^_`\{\|\}~]/);

var reHtmlTag = new RegExp('^' + HTMLTAG, 'i');

var reLinkTitle = new RegExp(
    '^(?:"(' + ESCAPED_CHAR + '|[^"\\x00])*"' +
        '|' +
        '\'(' + ESCAPED_CHAR + '|[^\'\\x00])*\'' +
        '|' +
        '\\((' + ESCAPED_CHAR + '|[^)\\x00])*\\))');

var reLinkDestinationBraces = new RegExp(
    '^(?:[<](?:[^<>\\n\\\\\\x00]' + '|' + ESCAPED_CHAR + '|' + '\\\\)*[>])');

var reLinkDestination = new RegExp(
    '^(?:' + REG_CHAR + '+|' + ESCAPED_CHAR + '|' + IN_PARENS_NOSP + ')*');

var reEscapable = new RegExp('^' + ESCAPABLE);

var reEntityHere = new RegExp('^' + ENTITY, 'i');

var reTicks = /`+/;

var reTicksHere = /^`+/;

var reEmailAutolink = /^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;

var reAutolink = /^<(?:coap|doi|javascript|aaa|aaas|about|acap|cap|cid|crid|data|dav|dict|dns|file|ftp|geo|go|gopher|h323|http|https|iax|icap|im|imap|info|ipp|iris|iris.beep|iris.xpc|iris.xpcs|iris.lwz|ldap|mailto|mid|msrp|msrps|mtqp|mupdate|news|nfs|ni|nih|nntp|opaquelocktoken|pop|pres|rtsp|service|session|shttp|sieve|sip|sips|sms|snmp|soap.beep|soap.beeps|tag|tel|telnet|tftp|thismessage|tn3270|tip|tv|urn|vemmi|ws|wss|xcon|xcon-userid|xmlrpc.beep|xmlrpc.beeps|xmpp|z39.50r|z39.50s|adiumxtra|afp|afs|aim|apt|attachment|aw|beshare|bitcoin|bolo|callto|chrome|chrome-extension|com-eventbrite-attendee|content|cvs|dlna-playsingle|dlna-playcontainer|dtn|dvb|ed2k|facetime|feed|finger|fish|gg|git|gizmoproject|gtalk|hcp|icon|ipn|irc|irc6|ircs|itms|jar|jms|keyparc|lastfm|ldaps|magnet|maps|market|message|mms|ms-help|msnim|mumble|mvn|notes|oid|palm|paparazzi|platform|proxy|psyc|query|res|resource|rmi|rsync|rtmp|secondlife|sftp|sgn|skype|smb|soldat|spotify|ssh|steam|svn|teamspeak|things|udp|unreal|ut2004|ventrilo|view-source|webcal|wtai|wyciwyg|xfire|xri|ymsgr):[^<>\x00-\x20]*>/i;

var reSpnl = /^ *(?:\n *)?/;

var reWhitespaceChar = /^\s/;

var reWhitespace = /\s+/g;

var reFinalSpace = / *$/;

var reInitialSpace = /^ */;

var reLinkLabel = /^\[(?:[^\\\[\]]|\\[\[\]]){0,1000}\]/;

// Matches a string of non-special characters.
var reMain = /^[^\n`\[\]\\!<&*_]+/m;

var text = function(s) {
    var node = new Node('Text');
    node._literal = s;
    return node;
};

// INLINE PARSER

// These are methods of an InlineParser object, defined below.
// An InlineParser keeps track of a subject (a string to be
// parsed) and a position in that subject.

// If re matches at current position in the subject, advance
// position in subject and return the match; otherwise return null.
var match = function(re) {
    var m = re.exec(this.subject.slice(this.pos));
    if (m) {
        this.pos += m.index + m[0].length;
        return m[0];
    } else {
        return null;
    }
};

// Returns the code for the character at the current subject position, or -1
// there are no more characters.
var peek = function() {
    if (this.pos < this.subject.length) {
        return this.subject.charCodeAt(this.pos);
    } else {
        return -1;
    }
};

// Parse zero or more space characters, including at most one newline
var spnl = function() {
    this.match(reSpnl);
    return 1;
};

// All of the parsers below try to match something at the current position
// in the subject.  If they succeed in matching anything, they
// return the inline matched, advancing the subject.

// Attempt to parse backticks, adding either a backtick code span or a
// literal sequence of backticks.
var parseBackticks = function(block) {
    var ticks = this.match(reTicksHere);
    if (ticks === null) {
        return 0;
    }
    var afterOpenTicks = this.pos;
    var matched;
    var node;
    while ((matched = this.match(reTicks)) !== null) {
        if (matched === ticks) {
            node = new Node('Code');
            node._literal = this.subject.slice(afterOpenTicks,
                                        this.pos - ticks.length)
                          .trim().replace(reWhitespace, ' ');
            block.appendChild(node);
            return true;
        }
    }
    // If we got here, we didn't match a closing backtick sequence.
    this.pos = afterOpenTicks;
    block.appendChild(text(ticks));
    return true;
};

// Parse a backslash-escaped special character, adding either the escaped
// character, a hard line break (if the backslash is followed by a newline),
// or a literal backslash to the block's children.  Assumes current character
// is a backslash.
var parseBackslash = function(block) {
    var subj = this.subject,
        pos = this.pos;
    var node;
    if (subj.charAt(pos + 1) === '\n') {
        this.pos = this.pos + 2;
        node = new Node('Hardbreak');
        block.appendChild(node);
    } else if (reEscapable.test(subj.charAt(pos + 1))) {
        this.pos = this.pos + 2;
        block.appendChild(text(subj.charAt(pos + 1)));
    } else {
        this.pos++;
        block.appendChild(text('\\'));
    }
    return true;
};

// Attempt to parse an autolink (URL or email in pointy brackets).
var parseAutolink = function(block) {
    var m;
    var dest;
    var node;
    if ((m = this.match(reEmailAutolink))) {
        dest = m.slice(1, m.length - 1);
        node = new Node('Link');
        node._destination = normalizeURI('mailto:' + dest);
        node._title = '';
        node.appendChild(text(dest));
        block.appendChild(node);
        return true;
    } else if ((m = this.match(reAutolink))) {
        dest = m.slice(1, m.length - 1);
        node = new Node('Link');
        node._destination = normalizeURI(dest);
        node._title = '';
        node.appendChild(text(dest));
        block.appendChild(node);
        return true;
    } else {
        return false;
    }
};

// Attempt to parse a raw HTML tag.
var parseHtmlTag = function(block) {
    var m = this.match(reHtmlTag);
    if (m === null) {
        return false;
    } else {
        var node = new Node('Html');
        node._literal = m;
        block.appendChild(node);
        return true;
    }
};

// Scan a sequence of characters with code cc, and return information about
// the number of delimiters and whether they are positioned such that
// they can open and/or close emphasis or strong emphasis.  A utility
// function for strong/emph parsing.
var scanDelims = function(cc) {
    var numdelims = 0;
    var char_before, char_after, cc_after;
    var startpos = this.pos;
    var left_flanking, right_flanking, can_open, can_close;

    char_before = this.pos === 0 ? '\n' :
        this.subject.charAt(this.pos - 1);

    while (this.peek() === cc) {
        numdelims++;
        this.pos++;
    }

    cc_after = this.peek();
    if (cc_after === -1) {
        char_after = '\n';
    } else {
        char_after = fromCodePoint(cc_after);
    }

    left_flanking = numdelims > 0 &&
            !(reWhitespaceChar.test(char_after)) &&
            !(rePunctuation.test(char_after) &&
             !(reWhitespaceChar.test(char_before)) &&
             !(rePunctuation.test(char_before)));
    right_flanking = numdelims > 0 &&
            !(reWhitespaceChar.test(char_before)) &&
            !(rePunctuation.test(char_before) &&
              !(reWhitespaceChar.test(char_after)) &&
              !(rePunctuation.test(char_after)));
    if (cc === C_UNDERSCORE) {
        can_open = left_flanking && !right_flanking;
        can_close = right_flanking && !left_flanking;
    } else {
        can_open = left_flanking;
        can_close = right_flanking;
    }
    this.pos = startpos;
    return { numdelims: numdelims,
             can_open: can_open,
             can_close: can_close };
};

// Attempt to parse emphasis or strong emphasis.
var parseEmphasis = function(cc, block) {
    var res = this.scanDelims(cc);
    var numdelims = res.numdelims;
    var startpos = this.pos;

    if (numdelims === 0) {
        return false;
    }

    this.pos += numdelims;
    var node = text(this.subject.slice(startpos, this.pos));
    block.appendChild(node);

    // Add entry to stack for this opener
    this.delimiters = { cc: cc,
                        numdelims: numdelims,
                        node: node,
                        previous: this.delimiters,
                        next: null,
                        can_open: res.can_open,
                        can_close: res.can_close,
                        active: true };
    if (this.delimiters.previous !== null) {
        this.delimiters.previous.next = this.delimiters;
    }

    return true;

};

var removeDelimiter = function(delim) {
    if (delim.previous !== null) {
        delim.previous.next = delim.next;
    }
    if (delim.next === null) {
        // top of stack
        this.delimiters = delim.previous;
    } else {
        delim.next.previous = delim.previous;
    }
};

var processEmphasis = function(block, stack_bottom) {
    var opener, closer;
    var opener_inl, closer_inl;
    var nextstack, tempstack;
    var use_delims;
    var tmp, next;

    // find first closer above stack_bottom:
    closer = this.delimiters;
    while (closer !== null && closer.previous !== stack_bottom) {
        closer = closer.previous;
    }
    // move forward, looking for closers, and handling each
    while (closer !== null) {
        if (closer.can_close && (closer.cc === C_UNDERSCORE || closer.cc === C_ASTERISK)) {
            // found emphasis closer. now look back for first matching opener:
            opener = closer.previous;
            while (opener !== null && opener !== stack_bottom) {
                if (opener.cc === closer.cc && opener.can_open) {
                    break;
                }
                opener = opener.previous;
            }
            if (opener !== null && opener !== stack_bottom) {
                // calculate actual number of delimiters used from this closer
                if (closer.numdelims < 3 || opener.numdelims < 3) {
                    use_delims = closer.numdelims <= opener.numdelims ?
                        closer.numdelims : opener.numdelims;
                } else {
                    use_delims = closer.numdelims % 2 === 0 ? 2 : 1;
                }

                opener_inl = opener.node;
                closer_inl = closer.node;

                // remove used delimiters from stack elts and inlines
                opener.numdelims -= use_delims;
                closer.numdelims -= use_delims;
                opener_inl._literal =
                    opener_inl._literal.slice(0,
                                     opener_inl._literal.length - use_delims);
                closer_inl._literal =
                    closer_inl._literal.slice(0,
                                     closer_inl._literal.length - use_delims);

                // build contents for new emph element
                var emph = new Node(use_delims === 1 ? 'Emph' : 'Strong');

                tmp = opener_inl._next;
                while (tmp && tmp !== closer_inl) {
                    next = tmp._next;
                    tmp.unlink();
                    emph.appendChild(tmp);
                    tmp = next;
                }

                opener_inl.insertAfter(emph);

                // remove elts btw opener and closer in delimiters stack
                tempstack = closer.previous;
                while (tempstack !== null && tempstack !== opener) {
                    nextstack = tempstack.previous;
                    this.removeDelimiter(tempstack);
                    tempstack = nextstack;
                }

                // if opener has 0 delims, remove it and the inline
                if (opener.numdelims === 0) {
                    opener_inl.unlink();
                    this.removeDelimiter(opener);
                }

                if (closer.numdelims === 0) {
                    closer_inl.unlink();
                    tempstack = closer.next;
                    this.removeDelimiter(closer);
                    closer = tempstack;
                }

            } else {
                closer = closer.next;
            }

        } else {
            closer = closer.next;
        }

    }

    // remove all delimiters
    while (this.delimiters !== stack_bottom) {
        this.removeDelimiter(this.delimiters);
    }
};

// Attempt to parse link title (sans quotes), returning the string
// or null if no match.
var parseLinkTitle = function() {
    var title = this.match(reLinkTitle);
    if (title === null) {
        return null;
    } else {
        // chop off quotes from title and unescape:
        return unescapeString(title.substr(1, title.length - 2));
    }
};

// Attempt to parse link destination, returning the string or
// null if no match.
var parseLinkDestination = function() {
    var res = this.match(reLinkDestinationBraces);
    if (res === null) {
        res = this.match(reLinkDestination);
        if (res === null) {
            return null;
        } else {
            return normalizeURI(unescapeString(res));
        }
    } else {  // chop off surrounding <..>:
        return normalizeURI(unescapeString(res.substr(1, res.length - 2)));
    }
};

// Attempt to parse a link label, returning number of characters parsed.
var parseLinkLabel = function() {
    var m = this.match(reLinkLabel);
    return m === null ? 0 : m.length;
};

// Add open bracket to delimiter stack and add a text node to block's children.
var parseOpenBracket = function(block) {
    var startpos = this.pos;
    this.pos += 1;

    var node = text('[');
    block.appendChild(node);

    // Add entry to stack for this opener
    this.delimiters = { cc: C_OPEN_BRACKET,
                        numdelims: 1,
                        node: node,
                        previous: this.delimiters,
                        next: null,
                        can_open: true,
                        can_close: false,
                        index: startpos,
                        active: true };
    if (this.delimiters.previous !== null) {
        this.delimiters.previous.next = this.delimiters;
    }

    return true;

};

// IF next character is [, and ! delimiter to delimiter stack and
// add a text node to block's children.  Otherwise just add a text node.
var parseBang = function(block) {
    var startpos = this.pos;
    this.pos += 1;
    if (this.peek() === C_OPEN_BRACKET) {
        this.pos += 1;

        var node = text('![');
        block.appendChild(node);

        // Add entry to stack for this opener
        this.delimiters = { cc: C_BANG,
                            numdelims: 1,
                            node: node,
                            previous: this.delimiters,
                            next: null,
                            can_open: true,
                            can_close: false,
                            index: startpos + 1,
                            active: true };
        if (this.delimiters.previous !== null) {
            this.delimiters.previous.next = this.delimiters;
        }
    } else {
        block.appendChild(text('!'));
    }
    return true;
};

// Try to match close bracket against an opening in the delimiter
// stack.  Add either a link or image, or a plain [ character,
// to block's children.  If there is a matching delimiter,
// remove it from the delimiter stack.
var parseCloseBracket = function(block) {
    var startpos;
    var is_image;
    var dest;
    var title;
    var matched = false;
    var reflabel;
    var opener;

    this.pos += 1;
    startpos = this.pos;

    // look through stack of delimiters for a [ or ![
    opener = this.delimiters;

    while (opener !== null) {
        if (opener.cc === C_OPEN_BRACKET || opener.cc === C_BANG) {
            break;
        }
        opener = opener.previous;
    }

    if (opener === null) {
        // no matched opener, just return a literal
        block.appendChild(text(']'));
        return true;
    }

    if (!opener.active) {
        // no matched opener, just return a literal
        block.appendChild(text(']'));
        // take opener off emphasis stack
        this.removeDelimiter(opener);
        return true;
    }

    // If we got here, open is a potential opener
    is_image = opener.cc === C_BANG;

    // Check to see if we have a link/image

    // Inline link?
    if (this.peek() === C_OPEN_PAREN) {
        this.pos++;
        if (this.spnl() &&
            ((dest = this.parseLinkDestination()) !== null) &&
            this.spnl() &&
            // make sure there's a space before the title:
            (reWhitespaceChar.test(this.subject.charAt(this.pos - 1)) &&
             (title = this.parseLinkTitle()) || true) &&
            this.spnl() &&
            this.subject.charAt(this.pos) === ')') {
            this.pos += 1;
            matched = true;
        }
    } else {

        // Next, see if there's a link label
        var savepos = this.pos;
        this.spnl();
        var beforelabel = this.pos;
        var n = this.parseLinkLabel();
        if (n === 0 || n === 2) {
            // empty or missing second label
            reflabel = this.subject.slice(opener.index, startpos);
        } else {
            reflabel = this.subject.slice(beforelabel, beforelabel + n);
        }
        if (n === 0) {
            // If shortcut reference link, rewind before spaces we skipped.
            this.pos = savepos;
        }

        // lookup rawlabel in refmap
        var link = this.refmap[normalizeReference(reflabel)];
        if (link) {
            dest = link.destination;
            title = link.title;
            matched = true;
        }
    }

    if (matched) {
        var node = new Node(is_image ? 'Image' : 'Link');
        node._destination = dest;
        node._title = title || '';

        var tmp, next;
        tmp = opener.node._next;
        while (tmp) {
            next = tmp._next;
            tmp.unlink();
            node.appendChild(tmp);
            tmp = next;
        }
        block.appendChild(node);
        this.processEmphasis(node, opener.previous);

        opener.node.unlink();

        // processEmphasis will remove this and later delimiters.
        // Now, for a link, we also deactivate earlier link openers.
        // (no links in links)
        if (!is_image) {
          opener = this.delimiters;
          while (opener !== null) {
            if (opener.cc === C_OPEN_BRACKET) {
                opener.active = false; // deactivate this opener
            }
            opener = opener.previous;
          }
        }

        return true;

    } else { // no match

        this.removeDelimiter(opener);  // remove this opener from stack
        this.pos = startpos;
        block.appendChild(text(']'));
        return true;
    }

};

// Attempt to parse an entity, return Entity object if successful.
var parseEntity = function(block) {
    var m;
    if ((m = this.match(reEntityHere))) {
        block.appendChild(text(entityToChar(m)));
        return true;
    } else {
        return false;
    }
};

// Parse a run of ordinary characters, or a single character with
// a special meaning in markdown, as a plain string.
var parseString = function(block) {
    var m;
    if ((m = this.match(reMain))) {
        block.appendChild(text(m));
        return true;
    } else {
        return false;
    }
};

// Parse a newline.  If it was preceded by two spaces, return a hard
// line break; otherwise a soft line break.
var parseNewline = function(block) {
    this.pos += 1; // assume we're at a \n
    // check previous node for trailing spaces
    var lastc = block._lastChild;
    if (lastc && lastc.type === 'Text') {
        var sps = reFinalSpace.exec(lastc._literal)[0].length;
        if (sps > 0) {
            lastc._literal = lastc._literal.replace(reFinalSpace, '');
        }
        block.appendChild(new Node(sps >= 2 ? 'Hardbreak' : 'Softbreak'));
    } else {
        block.appendChild(new Node('Softbreak'));
    }
    this.match(reInitialSpace); // gobble leading spaces in next line
    return true;
};

// Attempt to parse a link reference, modifying refmap.
var parseReference = function(s, refmap) {
    this.subject = s;
    this.pos = 0;
    var rawlabel;
    var dest;
    var title;
    var matchChars;
    var startpos = this.pos;

    // label:
    matchChars = this.parseLinkLabel();
    if (matchChars === 0) {
        return 0;
    } else {
        rawlabel = this.subject.substr(0, matchChars);
    }

    // colon:
    if (this.peek() === C_COLON) {
        this.pos++;
    } else {
        this.pos = startpos;
        return 0;
    }

    //  link url
    this.spnl();

    dest = this.parseLinkDestination();
    if (dest === null || dest.length === 0) {
        this.pos = startpos;
        return 0;
    }

    var beforetitle = this.pos;
    this.spnl();
    title = this.parseLinkTitle();
    if (title === null) {
        title = '';
        // rewind before spaces
        this.pos = beforetitle;
    }

    // make sure we're at line end:
    if (this.match(/^ *(?:\n|$)/) === null) {
        this.pos = startpos;
        return 0;
    }

    var normlabel = normalizeReference(rawlabel);

    if (!refmap[normlabel]) {
        refmap[normlabel] = { destination: dest, title: title };
    }
    return this.pos - startpos;
};

// Parse the next inline element in subject, advancing subject position.
// On success, add the result to block's children and return true.
// On failure, return false.
var parseInline = function(block) {
    var res = false;
    var c = this.peek();
    if (c === -1) {
        return false;
    }
    switch(c) {
    case C_NEWLINE:
        res = this.parseNewline(block);
        break;
    case C_BACKSLASH:
        res = this.parseBackslash(block);
        break;
    case C_BACKTICK:
        res = this.parseBackticks(block);
        break;
    case C_ASTERISK:
    case C_UNDERSCORE:
        res = this.parseEmphasis(c, block);
        break;
    case C_OPEN_BRACKET:
        res = this.parseOpenBracket(block);
        break;
    case C_BANG:
        res = this.parseBang(block);
        break;
    case C_CLOSE_BRACKET:
        res = this.parseCloseBracket(block);
        break;
    case C_LESSTHAN:
        res = this.parseAutolink(block) || this.parseHtmlTag(block);
        break;
    case C_AMPERSAND:
        res = this.parseEntity(block);
        break;
    default:
        res = this.parseString(block);
        break;
    }
    if (!res) {
        this.pos += 1;
        var textnode = new Node('Text');
        textnode._literal = fromCodePoint(c);
        block.appendChild(textnode);
    }

    return true;
};

// Parse string content in block into inline children,
// using refmap to resolve references.
var parseInlines = function(block) {
    this.subject = block._string_content.trim();
    this.pos = 0;
    this.delimiters = null;
    while (this.parseInline(block)) {
    }
    block._string_content = null; // allow raw string to be garbage collected
    this.processEmphasis(block, null);
};

// The InlineParser object.
function InlineParser(){
    return {
        subject: '',
        delimiters: null,  // used by parseEmphasis method
        pos: 0,
        refmap: {},
        match: match,
        peek: peek,
        spnl: spnl,
        parseBackticks: parseBackticks,
        parseBackslash: parseBackslash,
        parseAutolink: parseAutolink,
        parseHtmlTag: parseHtmlTag,
        scanDelims: scanDelims,
        parseEmphasis: parseEmphasis,
        parseLinkTitle: parseLinkTitle,
        parseLinkDestination: parseLinkDestination,
        parseLinkLabel: parseLinkLabel,
        parseOpenBracket: parseOpenBracket,
        parseCloseBracket: parseCloseBracket,
        parseBang: parseBang,
        parseEntity: parseEntity,
        parseString: parseString,
        parseNewline: parseNewline,
        parseReference: parseReference,
        parseInline: parseInline,
        processEmphasis: processEmphasis,
        removeDelimiter: removeDelimiter,
        parse: parseInlines
    };
}

module.exports = InlineParser;

},{"./common":2,"./from-code-point.js":3,"./html5-entities.js":5,"./node":8,"./normalize-reference":9}],8:[function(require,module,exports){
"use strict";

function isContainer(node) {
    switch (node._type) {
    case 'Document':
    case 'BlockQuote':
    case 'List':
    case 'Item':
    case 'Paragraph':
    case 'Header':
    case 'Emph':
    case 'Strong':
    case 'Link':
    case 'Image':
        return true;
    default:
        return false;
    }
}

var resumeAt = function(node, entering) {
    this.current = node;
    this.entering = (entering === true);
};

var next = function(){
    var cur = this.current;
    var entering = this.entering;

    if (cur === null) {
        return null;
    }

    var container = isContainer(cur);

    if (entering && container) {
        if (cur._firstChild) {
            this.current = cur._firstChild;
            this.entering = true;
        } else {
            // stay on node but exit
            this.entering = false;
        }

    } else if (cur._next === null) {
        this.current = cur._parent;
        this.entering = false;

    } else {
        this.current = cur._next;
        this.entering = true;
    }

    return {entering: entering, node: cur};
};

var NodeWalker = function(root) {
    return { current: root,
             root: root,
             entering: true,
             next: next,
             resumeAt: resumeAt };
};

var Node = function(nodeType, sourcepos) {
    this._type = nodeType;
    this._parent = null;
    this._firstChild = null;
    this._lastChild = null;
    this._prev = null;
    this._next = null;
    this._sourcepos = sourcepos;
    this._lastLineBlank = false;
    this._open = true;
    this._string_content = null;
    this._literal = null;
    this._listData = null;
    this._info = null;
    this._destination = null;
    this._title = null;
    this._isFenced = false;
    this._fenceChar = null;
    this._fenceLength = 0;
    this._fenceOffset = null;
    this._level = null;
};

var proto = Node.prototype;

Node.prototype.isContainer = function() {
    return isContainer(this);
};

Object.defineProperty(proto, 'type', {
    get: function() { return this._type; }
});

Object.defineProperty(proto, 'firstChild', {
    get: function() { return this._firstChild; }
});

Object.defineProperty(proto, 'lastChild', {
    get: function() { return this._lastChild; }
});

Object.defineProperty(proto, 'next', {
    get: function() { return this._next; }
});

Object.defineProperty(proto, 'prev', {
    get: function() { return this._prev; }
});

Object.defineProperty(proto, 'parent', {
    get: function() { return this._parent; }
});

Object.defineProperty(proto, 'sourcepos', {
    get: function() { return this._sourcepos; }
});

Object.defineProperty(proto, 'literal', {
    get: function() { return this._literal; },
    set: function(s) { this._literal = s; }
});

Object.defineProperty(proto, 'destination', {
    get: function() { return this._destination; },
    set: function(s) { this._destination = s; }
});

Object.defineProperty(proto, 'title', {
    get: function() { return this._title; },
    set: function(s) { this._title = s; }
});

Object.defineProperty(proto, 'info', {
    get: function() { return this._info; },
    set: function(s) { this._info = s; }
});

Object.defineProperty(proto, 'level', {
    get: function() { return this._level; },
    set: function(s) { this._level = s; }
});

Object.defineProperty(proto, 'listType', {
    get: function() { return this._listData.type; },
    set: function(t) { this._listData.type = t; }
});

Object.defineProperty(proto, 'listTight', {
    get: function() { return this._listData.tight; },
    set: function(t) { this._listData.tight = t; }
});

Object.defineProperty(proto, 'listStart', {
    get: function() { return this._listData.start; },
    set: function(n) { this._listData.start = n; }
});

Object.defineProperty(proto, 'listDelimiter', {
    get: function() { return this._listData.delimiter; },
    set: function(delim) { this._listData.delimiter = delim; }
});

Node.prototype.appendChild = function(child) {
    child.unlink();
    child._parent = this;
    if (this._lastChild) {
        this._lastChild._next = child;
        child._prev = this._lastChild;
        this._lastChild = child;
    } else {
        this._firstChild = child;
        this._lastChild = child;
    }
};

Node.prototype.prependChild = function(child) {
    child.unlink();
    child._parent = this;
    if (this._firstChild) {
        this._firstChild._prev = child;
        child._next = this._firstChild;
        this._firstChild = child;
    } else {
        this._firstChild = child;
        this._lastChild = child;
    }
};

Node.prototype.unlink = function() {
    if (this._prev) {
        this._prev._next = this._next;
    } else if (this._parent) {
        this._parent._firstChild = this._next;
    }
    if (this._next) {
        this._next._prev = this._prev;
    } else if (this._parent) {
        this._parent._lastChild = this._prev;
    }
    this._parent = null;
    this._next = null;
    this._prev = null;
};

Node.prototype.insertAfter = function(sibling) {
    sibling.unlink();
    sibling._next = this._next;
    if (sibling._next) {
        sibling._next._prev = sibling;
    }
    sibling._prev = this;
    this._next = sibling;
    sibling._parent = this._parent;
    if (!sibling._next) {
        sibling._parent._lastChild = sibling;
    }
};

Node.prototype.insertBefore = function(sibling) {
    sibling.unlink();
    sibling._prev = this._prev;
    if (sibling._prev) {
        sibling._prev._next = sibling;
    }
    sibling._next = this;
    this._prev = sibling;
    sibling._parent = this._parent;
    if (!sibling._prev) {
        sibling._parent._firstChild = sibling;
    }
};

Node.prototype.walker = function() {
    var walker = new NodeWalker(this);
    return walker;
};

module.exports = Node;


/* Example of use of walker:

 var walker = w.walker();
 var event;

 while (event = walker.next()) {
 console.log(event.entering, event.node.type());
 }

 */

},{}],9:[function(require,module,exports){
"use strict";

/* The bulk of this code derives from https://github.com/dmoscrop/fold-case
But in addition to case-folding, we also normalize whitespace.

fold-case is Copyright Mathias Bynens <https://mathiasbynens.be/>

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.
*/

/*eslint-disable  key-spacing, comma-spacing */

var regex = /[ \t\r\n]+|[A-Z\xB5\xC0-\xD6\xD8-\xDF\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u0149\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178\u0179\u017B\u017D\u017F\u0181\u0182\u0184\u0186\u0187\u0189-\u018B\u018E-\u0191\u0193\u0194\u0196-\u0198\u019C\u019D\u019F\u01A0\u01A2\u01A4\u01A6\u01A7\u01A9\u01AC\u01AE\u01AF\u01B1-\u01B3\u01B5\u01B7\u01B8\u01BC\u01C4\u01C5\u01C7\u01C8\u01CA\u01CB\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F0-\u01F2\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A\u023B\u023D\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0345\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03AB\u03B0\u03C2\u03CF-\u03D1\u03D5\u03D6\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F0\u03F1\u03F4\u03F5\u03F7\u03F9\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u0587\u10A0-\u10C5\u10C7\u10CD\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E96-\u1E9B\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F50\u1F52\u1F54\u1F56\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1F80-\u1FAF\u1FB2-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD2\u1FD3\u1FD6-\u1FDB\u1FE2-\u1FE4\u1FE6-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2126\u212A\u212B\u2132\u2160-\u216F\u2183\u24B6-\u24CF\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AD\uA7B0\uA7B1\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A]|\uD801[\uDC00-\uDC27]|\uD806[\uDCA0-\uDCBF]/g;

var map = {'A':'a','B':'b','C':'c','D':'d','E':'e','F':'f','G':'g','H':'h','I':'i','J':'j','K':'k','L':'l','M':'m','N':'n','O':'o','P':'p','Q':'q','R':'r','S':'s','T':'t','U':'u','V':'v','W':'w','X':'x','Y':'y','Z':'z','\xB5':'\u03BC','\xC0':'\xE0','\xC1':'\xE1','\xC2':'\xE2','\xC3':'\xE3','\xC4':'\xE4','\xC5':'\xE5','\xC6':'\xE6','\xC7':'\xE7','\xC8':'\xE8','\xC9':'\xE9','\xCA':'\xEA','\xCB':'\xEB','\xCC':'\xEC','\xCD':'\xED','\xCE':'\xEE','\xCF':'\xEF','\xD0':'\xF0','\xD1':'\xF1','\xD2':'\xF2','\xD3':'\xF3','\xD4':'\xF4','\xD5':'\xF5','\xD6':'\xF6','\xD8':'\xF8','\xD9':'\xF9','\xDA':'\xFA','\xDB':'\xFB','\xDC':'\xFC','\xDD':'\xFD','\xDE':'\xFE','\u0100':'\u0101','\u0102':'\u0103','\u0104':'\u0105','\u0106':'\u0107','\u0108':'\u0109','\u010A':'\u010B','\u010C':'\u010D','\u010E':'\u010F','\u0110':'\u0111','\u0112':'\u0113','\u0114':'\u0115','\u0116':'\u0117','\u0118':'\u0119','\u011A':'\u011B','\u011C':'\u011D','\u011E':'\u011F','\u0120':'\u0121','\u0122':'\u0123','\u0124':'\u0125','\u0126':'\u0127','\u0128':'\u0129','\u012A':'\u012B','\u012C':'\u012D','\u012E':'\u012F','\u0132':'\u0133','\u0134':'\u0135','\u0136':'\u0137','\u0139':'\u013A','\u013B':'\u013C','\u013D':'\u013E','\u013F':'\u0140','\u0141':'\u0142','\u0143':'\u0144','\u0145':'\u0146','\u0147':'\u0148','\u014A':'\u014B','\u014C':'\u014D','\u014E':'\u014F','\u0150':'\u0151','\u0152':'\u0153','\u0154':'\u0155','\u0156':'\u0157','\u0158':'\u0159','\u015A':'\u015B','\u015C':'\u015D','\u015E':'\u015F','\u0160':'\u0161','\u0162':'\u0163','\u0164':'\u0165','\u0166':'\u0167','\u0168':'\u0169','\u016A':'\u016B','\u016C':'\u016D','\u016E':'\u016F','\u0170':'\u0171','\u0172':'\u0173','\u0174':'\u0175','\u0176':'\u0177','\u0178':'\xFF','\u0179':'\u017A','\u017B':'\u017C','\u017D':'\u017E','\u017F':'s','\u0181':'\u0253','\u0182':'\u0183','\u0184':'\u0185','\u0186':'\u0254','\u0187':'\u0188','\u0189':'\u0256','\u018A':'\u0257','\u018B':'\u018C','\u018E':'\u01DD','\u018F':'\u0259','\u0190':'\u025B','\u0191':'\u0192','\u0193':'\u0260','\u0194':'\u0263','\u0196':'\u0269','\u0197':'\u0268','\u0198':'\u0199','\u019C':'\u026F','\u019D':'\u0272','\u019F':'\u0275','\u01A0':'\u01A1','\u01A2':'\u01A3','\u01A4':'\u01A5','\u01A6':'\u0280','\u01A7':'\u01A8','\u01A9':'\u0283','\u01AC':'\u01AD','\u01AE':'\u0288','\u01AF':'\u01B0','\u01B1':'\u028A','\u01B2':'\u028B','\u01B3':'\u01B4','\u01B5':'\u01B6','\u01B7':'\u0292','\u01B8':'\u01B9','\u01BC':'\u01BD','\u01C4':'\u01C6','\u01C5':'\u01C6','\u01C7':'\u01C9','\u01C8':'\u01C9','\u01CA':'\u01CC','\u01CB':'\u01CC','\u01CD':'\u01CE','\u01CF':'\u01D0','\u01D1':'\u01D2','\u01D3':'\u01D4','\u01D5':'\u01D6','\u01D7':'\u01D8','\u01D9':'\u01DA','\u01DB':'\u01DC','\u01DE':'\u01DF','\u01E0':'\u01E1','\u01E2':'\u01E3','\u01E4':'\u01E5','\u01E6':'\u01E7','\u01E8':'\u01E9','\u01EA':'\u01EB','\u01EC':'\u01ED','\u01EE':'\u01EF','\u01F1':'\u01F3','\u01F2':'\u01F3','\u01F4':'\u01F5','\u01F6':'\u0195','\u01F7':'\u01BF','\u01F8':'\u01F9','\u01FA':'\u01FB','\u01FC':'\u01FD','\u01FE':'\u01FF','\u0200':'\u0201','\u0202':'\u0203','\u0204':'\u0205','\u0206':'\u0207','\u0208':'\u0209','\u020A':'\u020B','\u020C':'\u020D','\u020E':'\u020F','\u0210':'\u0211','\u0212':'\u0213','\u0214':'\u0215','\u0216':'\u0217','\u0218':'\u0219','\u021A':'\u021B','\u021C':'\u021D','\u021E':'\u021F','\u0220':'\u019E','\u0222':'\u0223','\u0224':'\u0225','\u0226':'\u0227','\u0228':'\u0229','\u022A':'\u022B','\u022C':'\u022D','\u022E':'\u022F','\u0230':'\u0231','\u0232':'\u0233','\u023A':'\u2C65','\u023B':'\u023C','\u023D':'\u019A','\u023E':'\u2C66','\u0241':'\u0242','\u0243':'\u0180','\u0244':'\u0289','\u0245':'\u028C','\u0246':'\u0247','\u0248':'\u0249','\u024A':'\u024B','\u024C':'\u024D','\u024E':'\u024F','\u0345':'\u03B9','\u0370':'\u0371','\u0372':'\u0373','\u0376':'\u0377','\u037F':'\u03F3','\u0386':'\u03AC','\u0388':'\u03AD','\u0389':'\u03AE','\u038A':'\u03AF','\u038C':'\u03CC','\u038E':'\u03CD','\u038F':'\u03CE','\u0391':'\u03B1','\u0392':'\u03B2','\u0393':'\u03B3','\u0394':'\u03B4','\u0395':'\u03B5','\u0396':'\u03B6','\u0397':'\u03B7','\u0398':'\u03B8','\u0399':'\u03B9','\u039A':'\u03BA','\u039B':'\u03BB','\u039C':'\u03BC','\u039D':'\u03BD','\u039E':'\u03BE','\u039F':'\u03BF','\u03A0':'\u03C0','\u03A1':'\u03C1','\u03A3':'\u03C3','\u03A4':'\u03C4','\u03A5':'\u03C5','\u03A6':'\u03C6','\u03A7':'\u03C7','\u03A8':'\u03C8','\u03A9':'\u03C9','\u03AA':'\u03CA','\u03AB':'\u03CB','\u03C2':'\u03C3','\u03CF':'\u03D7','\u03D0':'\u03B2','\u03D1':'\u03B8','\u03D5':'\u03C6','\u03D6':'\u03C0','\u03D8':'\u03D9','\u03DA':'\u03DB','\u03DC':'\u03DD','\u03DE':'\u03DF','\u03E0':'\u03E1','\u03E2':'\u03E3','\u03E4':'\u03E5','\u03E6':'\u03E7','\u03E8':'\u03E9','\u03EA':'\u03EB','\u03EC':'\u03ED','\u03EE':'\u03EF','\u03F0':'\u03BA','\u03F1':'\u03C1','\u03F4':'\u03B8','\u03F5':'\u03B5','\u03F7':'\u03F8','\u03F9':'\u03F2','\u03FA':'\u03FB','\u03FD':'\u037B','\u03FE':'\u037C','\u03FF':'\u037D','\u0400':'\u0450','\u0401':'\u0451','\u0402':'\u0452','\u0403':'\u0453','\u0404':'\u0454','\u0405':'\u0455','\u0406':'\u0456','\u0407':'\u0457','\u0408':'\u0458','\u0409':'\u0459','\u040A':'\u045A','\u040B':'\u045B','\u040C':'\u045C','\u040D':'\u045D','\u040E':'\u045E','\u040F':'\u045F','\u0410':'\u0430','\u0411':'\u0431','\u0412':'\u0432','\u0413':'\u0433','\u0414':'\u0434','\u0415':'\u0435','\u0416':'\u0436','\u0417':'\u0437','\u0418':'\u0438','\u0419':'\u0439','\u041A':'\u043A','\u041B':'\u043B','\u041C':'\u043C','\u041D':'\u043D','\u041E':'\u043E','\u041F':'\u043F','\u0420':'\u0440','\u0421':'\u0441','\u0422':'\u0442','\u0423':'\u0443','\u0424':'\u0444','\u0425':'\u0445','\u0426':'\u0446','\u0427':'\u0447','\u0428':'\u0448','\u0429':'\u0449','\u042A':'\u044A','\u042B':'\u044B','\u042C':'\u044C','\u042D':'\u044D','\u042E':'\u044E','\u042F':'\u044F','\u0460':'\u0461','\u0462':'\u0463','\u0464':'\u0465','\u0466':'\u0467','\u0468':'\u0469','\u046A':'\u046B','\u046C':'\u046D','\u046E':'\u046F','\u0470':'\u0471','\u0472':'\u0473','\u0474':'\u0475','\u0476':'\u0477','\u0478':'\u0479','\u047A':'\u047B','\u047C':'\u047D','\u047E':'\u047F','\u0480':'\u0481','\u048A':'\u048B','\u048C':'\u048D','\u048E':'\u048F','\u0490':'\u0491','\u0492':'\u0493','\u0494':'\u0495','\u0496':'\u0497','\u0498':'\u0499','\u049A':'\u049B','\u049C':'\u049D','\u049E':'\u049F','\u04A0':'\u04A1','\u04A2':'\u04A3','\u04A4':'\u04A5','\u04A6':'\u04A7','\u04A8':'\u04A9','\u04AA':'\u04AB','\u04AC':'\u04AD','\u04AE':'\u04AF','\u04B0':'\u04B1','\u04B2':'\u04B3','\u04B4':'\u04B5','\u04B6':'\u04B7','\u04B8':'\u04B9','\u04BA':'\u04BB','\u04BC':'\u04BD','\u04BE':'\u04BF','\u04C0':'\u04CF','\u04C1':'\u04C2','\u04C3':'\u04C4','\u04C5':'\u04C6','\u04C7':'\u04C8','\u04C9':'\u04CA','\u04CB':'\u04CC','\u04CD':'\u04CE','\u04D0':'\u04D1','\u04D2':'\u04D3','\u04D4':'\u04D5','\u04D6':'\u04D7','\u04D8':'\u04D9','\u04DA':'\u04DB','\u04DC':'\u04DD','\u04DE':'\u04DF','\u04E0':'\u04E1','\u04E2':'\u04E3','\u04E4':'\u04E5','\u04E6':'\u04E7','\u04E8':'\u04E9','\u04EA':'\u04EB','\u04EC':'\u04ED','\u04EE':'\u04EF','\u04F0':'\u04F1','\u04F2':'\u04F3','\u04F4':'\u04F5','\u04F6':'\u04F7','\u04F8':'\u04F9','\u04FA':'\u04FB','\u04FC':'\u04FD','\u04FE':'\u04FF','\u0500':'\u0501','\u0502':'\u0503','\u0504':'\u0505','\u0506':'\u0507','\u0508':'\u0509','\u050A':'\u050B','\u050C':'\u050D','\u050E':'\u050F','\u0510':'\u0511','\u0512':'\u0513','\u0514':'\u0515','\u0516':'\u0517','\u0518':'\u0519','\u051A':'\u051B','\u051C':'\u051D','\u051E':'\u051F','\u0520':'\u0521','\u0522':'\u0523','\u0524':'\u0525','\u0526':'\u0527','\u0528':'\u0529','\u052A':'\u052B','\u052C':'\u052D','\u052E':'\u052F','\u0531':'\u0561','\u0532':'\u0562','\u0533':'\u0563','\u0534':'\u0564','\u0535':'\u0565','\u0536':'\u0566','\u0537':'\u0567','\u0538':'\u0568','\u0539':'\u0569','\u053A':'\u056A','\u053B':'\u056B','\u053C':'\u056C','\u053D':'\u056D','\u053E':'\u056E','\u053F':'\u056F','\u0540':'\u0570','\u0541':'\u0571','\u0542':'\u0572','\u0543':'\u0573','\u0544':'\u0574','\u0545':'\u0575','\u0546':'\u0576','\u0547':'\u0577','\u0548':'\u0578','\u0549':'\u0579','\u054A':'\u057A','\u054B':'\u057B','\u054C':'\u057C','\u054D':'\u057D','\u054E':'\u057E','\u054F':'\u057F','\u0550':'\u0580','\u0551':'\u0581','\u0552':'\u0582','\u0553':'\u0583','\u0554':'\u0584','\u0555':'\u0585','\u0556':'\u0586','\u10A0':'\u2D00','\u10A1':'\u2D01','\u10A2':'\u2D02','\u10A3':'\u2D03','\u10A4':'\u2D04','\u10A5':'\u2D05','\u10A6':'\u2D06','\u10A7':'\u2D07','\u10A8':'\u2D08','\u10A9':'\u2D09','\u10AA':'\u2D0A','\u10AB':'\u2D0B','\u10AC':'\u2D0C','\u10AD':'\u2D0D','\u10AE':'\u2D0E','\u10AF':'\u2D0F','\u10B0':'\u2D10','\u10B1':'\u2D11','\u10B2':'\u2D12','\u10B3':'\u2D13','\u10B4':'\u2D14','\u10B5':'\u2D15','\u10B6':'\u2D16','\u10B7':'\u2D17','\u10B8':'\u2D18','\u10B9':'\u2D19','\u10BA':'\u2D1A','\u10BB':'\u2D1B','\u10BC':'\u2D1C','\u10BD':'\u2D1D','\u10BE':'\u2D1E','\u10BF':'\u2D1F','\u10C0':'\u2D20','\u10C1':'\u2D21','\u10C2':'\u2D22','\u10C3':'\u2D23','\u10C4':'\u2D24','\u10C5':'\u2D25','\u10C7':'\u2D27','\u10CD':'\u2D2D','\u1E00':'\u1E01','\u1E02':'\u1E03','\u1E04':'\u1E05','\u1E06':'\u1E07','\u1E08':'\u1E09','\u1E0A':'\u1E0B','\u1E0C':'\u1E0D','\u1E0E':'\u1E0F','\u1E10':'\u1E11','\u1E12':'\u1E13','\u1E14':'\u1E15','\u1E16':'\u1E17','\u1E18':'\u1E19','\u1E1A':'\u1E1B','\u1E1C':'\u1E1D','\u1E1E':'\u1E1F','\u1E20':'\u1E21','\u1E22':'\u1E23','\u1E24':'\u1E25','\u1E26':'\u1E27','\u1E28':'\u1E29','\u1E2A':'\u1E2B','\u1E2C':'\u1E2D','\u1E2E':'\u1E2F','\u1E30':'\u1E31','\u1E32':'\u1E33','\u1E34':'\u1E35','\u1E36':'\u1E37','\u1E38':'\u1E39','\u1E3A':'\u1E3B','\u1E3C':'\u1E3D','\u1E3E':'\u1E3F','\u1E40':'\u1E41','\u1E42':'\u1E43','\u1E44':'\u1E45','\u1E46':'\u1E47','\u1E48':'\u1E49','\u1E4A':'\u1E4B','\u1E4C':'\u1E4D','\u1E4E':'\u1E4F','\u1E50':'\u1E51','\u1E52':'\u1E53','\u1E54':'\u1E55','\u1E56':'\u1E57','\u1E58':'\u1E59','\u1E5A':'\u1E5B','\u1E5C':'\u1E5D','\u1E5E':'\u1E5F','\u1E60':'\u1E61','\u1E62':'\u1E63','\u1E64':'\u1E65','\u1E66':'\u1E67','\u1E68':'\u1E69','\u1E6A':'\u1E6B','\u1E6C':'\u1E6D','\u1E6E':'\u1E6F','\u1E70':'\u1E71','\u1E72':'\u1E73','\u1E74':'\u1E75','\u1E76':'\u1E77','\u1E78':'\u1E79','\u1E7A':'\u1E7B','\u1E7C':'\u1E7D','\u1E7E':'\u1E7F','\u1E80':'\u1E81','\u1E82':'\u1E83','\u1E84':'\u1E85','\u1E86':'\u1E87','\u1E88':'\u1E89','\u1E8A':'\u1E8B','\u1E8C':'\u1E8D','\u1E8E':'\u1E8F','\u1E90':'\u1E91','\u1E92':'\u1E93','\u1E94':'\u1E95','\u1E9B':'\u1E61','\u1EA0':'\u1EA1','\u1EA2':'\u1EA3','\u1EA4':'\u1EA5','\u1EA6':'\u1EA7','\u1EA8':'\u1EA9','\u1EAA':'\u1EAB','\u1EAC':'\u1EAD','\u1EAE':'\u1EAF','\u1EB0':'\u1EB1','\u1EB2':'\u1EB3','\u1EB4':'\u1EB5','\u1EB6':'\u1EB7','\u1EB8':'\u1EB9','\u1EBA':'\u1EBB','\u1EBC':'\u1EBD','\u1EBE':'\u1EBF','\u1EC0':'\u1EC1','\u1EC2':'\u1EC3','\u1EC4':'\u1EC5','\u1EC6':'\u1EC7','\u1EC8':'\u1EC9','\u1ECA':'\u1ECB','\u1ECC':'\u1ECD','\u1ECE':'\u1ECF','\u1ED0':'\u1ED1','\u1ED2':'\u1ED3','\u1ED4':'\u1ED5','\u1ED6':'\u1ED7','\u1ED8':'\u1ED9','\u1EDA':'\u1EDB','\u1EDC':'\u1EDD','\u1EDE':'\u1EDF','\u1EE0':'\u1EE1','\u1EE2':'\u1EE3','\u1EE4':'\u1EE5','\u1EE6':'\u1EE7','\u1EE8':'\u1EE9','\u1EEA':'\u1EEB','\u1EEC':'\u1EED','\u1EEE':'\u1EEF','\u1EF0':'\u1EF1','\u1EF2':'\u1EF3','\u1EF4':'\u1EF5','\u1EF6':'\u1EF7','\u1EF8':'\u1EF9','\u1EFA':'\u1EFB','\u1EFC':'\u1EFD','\u1EFE':'\u1EFF','\u1F08':'\u1F00','\u1F09':'\u1F01','\u1F0A':'\u1F02','\u1F0B':'\u1F03','\u1F0C':'\u1F04','\u1F0D':'\u1F05','\u1F0E':'\u1F06','\u1F0F':'\u1F07','\u1F18':'\u1F10','\u1F19':'\u1F11','\u1F1A':'\u1F12','\u1F1B':'\u1F13','\u1F1C':'\u1F14','\u1F1D':'\u1F15','\u1F28':'\u1F20','\u1F29':'\u1F21','\u1F2A':'\u1F22','\u1F2B':'\u1F23','\u1F2C':'\u1F24','\u1F2D':'\u1F25','\u1F2E':'\u1F26','\u1F2F':'\u1F27','\u1F38':'\u1F30','\u1F39':'\u1F31','\u1F3A':'\u1F32','\u1F3B':'\u1F33','\u1F3C':'\u1F34','\u1F3D':'\u1F35','\u1F3E':'\u1F36','\u1F3F':'\u1F37','\u1F48':'\u1F40','\u1F49':'\u1F41','\u1F4A':'\u1F42','\u1F4B':'\u1F43','\u1F4C':'\u1F44','\u1F4D':'\u1F45','\u1F59':'\u1F51','\u1F5B':'\u1F53','\u1F5D':'\u1F55','\u1F5F':'\u1F57','\u1F68':'\u1F60','\u1F69':'\u1F61','\u1F6A':'\u1F62','\u1F6B':'\u1F63','\u1F6C':'\u1F64','\u1F6D':'\u1F65','\u1F6E':'\u1F66','\u1F6F':'\u1F67','\u1FB8':'\u1FB0','\u1FB9':'\u1FB1','\u1FBA':'\u1F70','\u1FBB':'\u1F71','\u1FBE':'\u03B9','\u1FC8':'\u1F72','\u1FC9':'\u1F73','\u1FCA':'\u1F74','\u1FCB':'\u1F75','\u1FD8':'\u1FD0','\u1FD9':'\u1FD1','\u1FDA':'\u1F76','\u1FDB':'\u1F77','\u1FE8':'\u1FE0','\u1FE9':'\u1FE1','\u1FEA':'\u1F7A','\u1FEB':'\u1F7B','\u1FEC':'\u1FE5','\u1FF8':'\u1F78','\u1FF9':'\u1F79','\u1FFA':'\u1F7C','\u1FFB':'\u1F7D','\u2126':'\u03C9','\u212A':'k','\u212B':'\xE5','\u2132':'\u214E','\u2160':'\u2170','\u2161':'\u2171','\u2162':'\u2172','\u2163':'\u2173','\u2164':'\u2174','\u2165':'\u2175','\u2166':'\u2176','\u2167':'\u2177','\u2168':'\u2178','\u2169':'\u2179','\u216A':'\u217A','\u216B':'\u217B','\u216C':'\u217C','\u216D':'\u217D','\u216E':'\u217E','\u216F':'\u217F','\u2183':'\u2184','\u24B6':'\u24D0','\u24B7':'\u24D1','\u24B8':'\u24D2','\u24B9':'\u24D3','\u24BA':'\u24D4','\u24BB':'\u24D5','\u24BC':'\u24D6','\u24BD':'\u24D7','\u24BE':'\u24D8','\u24BF':'\u24D9','\u24C0':'\u24DA','\u24C1':'\u24DB','\u24C2':'\u24DC','\u24C3':'\u24DD','\u24C4':'\u24DE','\u24C5':'\u24DF','\u24C6':'\u24E0','\u24C7':'\u24E1','\u24C8':'\u24E2','\u24C9':'\u24E3','\u24CA':'\u24E4','\u24CB':'\u24E5','\u24CC':'\u24E6','\u24CD':'\u24E7','\u24CE':'\u24E8','\u24CF':'\u24E9','\u2C00':'\u2C30','\u2C01':'\u2C31','\u2C02':'\u2C32','\u2C03':'\u2C33','\u2C04':'\u2C34','\u2C05':'\u2C35','\u2C06':'\u2C36','\u2C07':'\u2C37','\u2C08':'\u2C38','\u2C09':'\u2C39','\u2C0A':'\u2C3A','\u2C0B':'\u2C3B','\u2C0C':'\u2C3C','\u2C0D':'\u2C3D','\u2C0E':'\u2C3E','\u2C0F':'\u2C3F','\u2C10':'\u2C40','\u2C11':'\u2C41','\u2C12':'\u2C42','\u2C13':'\u2C43','\u2C14':'\u2C44','\u2C15':'\u2C45','\u2C16':'\u2C46','\u2C17':'\u2C47','\u2C18':'\u2C48','\u2C19':'\u2C49','\u2C1A':'\u2C4A','\u2C1B':'\u2C4B','\u2C1C':'\u2C4C','\u2C1D':'\u2C4D','\u2C1E':'\u2C4E','\u2C1F':'\u2C4F','\u2C20':'\u2C50','\u2C21':'\u2C51','\u2C22':'\u2C52','\u2C23':'\u2C53','\u2C24':'\u2C54','\u2C25':'\u2C55','\u2C26':'\u2C56','\u2C27':'\u2C57','\u2C28':'\u2C58','\u2C29':'\u2C59','\u2C2A':'\u2C5A','\u2C2B':'\u2C5B','\u2C2C':'\u2C5C','\u2C2D':'\u2C5D','\u2C2E':'\u2C5E','\u2C60':'\u2C61','\u2C62':'\u026B','\u2C63':'\u1D7D','\u2C64':'\u027D','\u2C67':'\u2C68','\u2C69':'\u2C6A','\u2C6B':'\u2C6C','\u2C6D':'\u0251','\u2C6E':'\u0271','\u2C6F':'\u0250','\u2C70':'\u0252','\u2C72':'\u2C73','\u2C75':'\u2C76','\u2C7E':'\u023F','\u2C7F':'\u0240','\u2C80':'\u2C81','\u2C82':'\u2C83','\u2C84':'\u2C85','\u2C86':'\u2C87','\u2C88':'\u2C89','\u2C8A':'\u2C8B','\u2C8C':'\u2C8D','\u2C8E':'\u2C8F','\u2C90':'\u2C91','\u2C92':'\u2C93','\u2C94':'\u2C95','\u2C96':'\u2C97','\u2C98':'\u2C99','\u2C9A':'\u2C9B','\u2C9C':'\u2C9D','\u2C9E':'\u2C9F','\u2CA0':'\u2CA1','\u2CA2':'\u2CA3','\u2CA4':'\u2CA5','\u2CA6':'\u2CA7','\u2CA8':'\u2CA9','\u2CAA':'\u2CAB','\u2CAC':'\u2CAD','\u2CAE':'\u2CAF','\u2CB0':'\u2CB1','\u2CB2':'\u2CB3','\u2CB4':'\u2CB5','\u2CB6':'\u2CB7','\u2CB8':'\u2CB9','\u2CBA':'\u2CBB','\u2CBC':'\u2CBD','\u2CBE':'\u2CBF','\u2CC0':'\u2CC1','\u2CC2':'\u2CC3','\u2CC4':'\u2CC5','\u2CC6':'\u2CC7','\u2CC8':'\u2CC9','\u2CCA':'\u2CCB','\u2CCC':'\u2CCD','\u2CCE':'\u2CCF','\u2CD0':'\u2CD1','\u2CD2':'\u2CD3','\u2CD4':'\u2CD5','\u2CD6':'\u2CD7','\u2CD8':'\u2CD9','\u2CDA':'\u2CDB','\u2CDC':'\u2CDD','\u2CDE':'\u2CDF','\u2CE0':'\u2CE1','\u2CE2':'\u2CE3','\u2CEB':'\u2CEC','\u2CED':'\u2CEE','\u2CF2':'\u2CF3','\uA640':'\uA641','\uA642':'\uA643','\uA644':'\uA645','\uA646':'\uA647','\uA648':'\uA649','\uA64A':'\uA64B','\uA64C':'\uA64D','\uA64E':'\uA64F','\uA650':'\uA651','\uA652':'\uA653','\uA654':'\uA655','\uA656':'\uA657','\uA658':'\uA659','\uA65A':'\uA65B','\uA65C':'\uA65D','\uA65E':'\uA65F','\uA660':'\uA661','\uA662':'\uA663','\uA664':'\uA665','\uA666':'\uA667','\uA668':'\uA669','\uA66A':'\uA66B','\uA66C':'\uA66D','\uA680':'\uA681','\uA682':'\uA683','\uA684':'\uA685','\uA686':'\uA687','\uA688':'\uA689','\uA68A':'\uA68B','\uA68C':'\uA68D','\uA68E':'\uA68F','\uA690':'\uA691','\uA692':'\uA693','\uA694':'\uA695','\uA696':'\uA697','\uA698':'\uA699','\uA69A':'\uA69B','\uA722':'\uA723','\uA724':'\uA725','\uA726':'\uA727','\uA728':'\uA729','\uA72A':'\uA72B','\uA72C':'\uA72D','\uA72E':'\uA72F','\uA732':'\uA733','\uA734':'\uA735','\uA736':'\uA737','\uA738':'\uA739','\uA73A':'\uA73B','\uA73C':'\uA73D','\uA73E':'\uA73F','\uA740':'\uA741','\uA742':'\uA743','\uA744':'\uA745','\uA746':'\uA747','\uA748':'\uA749','\uA74A':'\uA74B','\uA74C':'\uA74D','\uA74E':'\uA74F','\uA750':'\uA751','\uA752':'\uA753','\uA754':'\uA755','\uA756':'\uA757','\uA758':'\uA759','\uA75A':'\uA75B','\uA75C':'\uA75D','\uA75E':'\uA75F','\uA760':'\uA761','\uA762':'\uA763','\uA764':'\uA765','\uA766':'\uA767','\uA768':'\uA769','\uA76A':'\uA76B','\uA76C':'\uA76D','\uA76E':'\uA76F','\uA779':'\uA77A','\uA77B':'\uA77C','\uA77D':'\u1D79','\uA77E':'\uA77F','\uA780':'\uA781','\uA782':'\uA783','\uA784':'\uA785','\uA786':'\uA787','\uA78B':'\uA78C','\uA78D':'\u0265','\uA790':'\uA791','\uA792':'\uA793','\uA796':'\uA797','\uA798':'\uA799','\uA79A':'\uA79B','\uA79C':'\uA79D','\uA79E':'\uA79F','\uA7A0':'\uA7A1','\uA7A2':'\uA7A3','\uA7A4':'\uA7A5','\uA7A6':'\uA7A7','\uA7A8':'\uA7A9','\uA7AA':'\u0266','\uA7AB':'\u025C','\uA7AC':'\u0261','\uA7AD':'\u026C','\uA7B0':'\u029E','\uA7B1':'\u0287','\uFF21':'\uFF41','\uFF22':'\uFF42','\uFF23':'\uFF43','\uFF24':'\uFF44','\uFF25':'\uFF45','\uFF26':'\uFF46','\uFF27':'\uFF47','\uFF28':'\uFF48','\uFF29':'\uFF49','\uFF2A':'\uFF4A','\uFF2B':'\uFF4B','\uFF2C':'\uFF4C','\uFF2D':'\uFF4D','\uFF2E':'\uFF4E','\uFF2F':'\uFF4F','\uFF30':'\uFF50','\uFF31':'\uFF51','\uFF32':'\uFF52','\uFF33':'\uFF53','\uFF34':'\uFF54','\uFF35':'\uFF55','\uFF36':'\uFF56','\uFF37':'\uFF57','\uFF38':'\uFF58','\uFF39':'\uFF59','\uFF3A':'\uFF5A','\uD801\uDC00':'\uD801\uDC28','\uD801\uDC01':'\uD801\uDC29','\uD801\uDC02':'\uD801\uDC2A','\uD801\uDC03':'\uD801\uDC2B','\uD801\uDC04':'\uD801\uDC2C','\uD801\uDC05':'\uD801\uDC2D','\uD801\uDC06':'\uD801\uDC2E','\uD801\uDC07':'\uD801\uDC2F','\uD801\uDC08':'\uD801\uDC30','\uD801\uDC09':'\uD801\uDC31','\uD801\uDC0A':'\uD801\uDC32','\uD801\uDC0B':'\uD801\uDC33','\uD801\uDC0C':'\uD801\uDC34','\uD801\uDC0D':'\uD801\uDC35','\uD801\uDC0E':'\uD801\uDC36','\uD801\uDC0F':'\uD801\uDC37','\uD801\uDC10':'\uD801\uDC38','\uD801\uDC11':'\uD801\uDC39','\uD801\uDC12':'\uD801\uDC3A','\uD801\uDC13':'\uD801\uDC3B','\uD801\uDC14':'\uD801\uDC3C','\uD801\uDC15':'\uD801\uDC3D','\uD801\uDC16':'\uD801\uDC3E','\uD801\uDC17':'\uD801\uDC3F','\uD801\uDC18':'\uD801\uDC40','\uD801\uDC19':'\uD801\uDC41','\uD801\uDC1A':'\uD801\uDC42','\uD801\uDC1B':'\uD801\uDC43','\uD801\uDC1C':'\uD801\uDC44','\uD801\uDC1D':'\uD801\uDC45','\uD801\uDC1E':'\uD801\uDC46','\uD801\uDC1F':'\uD801\uDC47','\uD801\uDC20':'\uD801\uDC48','\uD801\uDC21':'\uD801\uDC49','\uD801\uDC22':'\uD801\uDC4A','\uD801\uDC23':'\uD801\uDC4B','\uD801\uDC24':'\uD801\uDC4C','\uD801\uDC25':'\uD801\uDC4D','\uD801\uDC26':'\uD801\uDC4E','\uD801\uDC27':'\uD801\uDC4F','\uD806\uDCA0':'\uD806\uDCC0','\uD806\uDCA1':'\uD806\uDCC1','\uD806\uDCA2':'\uD806\uDCC2','\uD806\uDCA3':'\uD806\uDCC3','\uD806\uDCA4':'\uD806\uDCC4','\uD806\uDCA5':'\uD806\uDCC5','\uD806\uDCA6':'\uD806\uDCC6','\uD806\uDCA7':'\uD806\uDCC7','\uD806\uDCA8':'\uD806\uDCC8','\uD806\uDCA9':'\uD806\uDCC9','\uD806\uDCAA':'\uD806\uDCCA','\uD806\uDCAB':'\uD806\uDCCB','\uD806\uDCAC':'\uD806\uDCCC','\uD806\uDCAD':'\uD806\uDCCD','\uD806\uDCAE':'\uD806\uDCCE','\uD806\uDCAF':'\uD806\uDCCF','\uD806\uDCB0':'\uD806\uDCD0','\uD806\uDCB1':'\uD806\uDCD1','\uD806\uDCB2':'\uD806\uDCD2','\uD806\uDCB3':'\uD806\uDCD3','\uD806\uDCB4':'\uD806\uDCD4','\uD806\uDCB5':'\uD806\uDCD5','\uD806\uDCB6':'\uD806\uDCD6','\uD806\uDCB7':'\uD806\uDCD7','\uD806\uDCB8':'\uD806\uDCD8','\uD806\uDCB9':'\uD806\uDCD9','\uD806\uDCBA':'\uD806\uDCDA','\uD806\uDCBB':'\uD806\uDCDB','\uD806\uDCBC':'\uD806\uDCDC','\uD806\uDCBD':'\uD806\uDCDD','\uD806\uDCBE':'\uD806\uDCDE','\uD806\uDCBF':'\uD806\uDCDF','\xDF':'ss','\u0130':'i\u0307','\u0149':'\u02BCn','\u01F0':'j\u030C','\u0390':'\u03B9\u0308\u0301','\u03B0':'\u03C5\u0308\u0301','\u0587':'\u0565\u0582','\u1E96':'h\u0331','\u1E97':'t\u0308','\u1E98':'w\u030A','\u1E99':'y\u030A','\u1E9A':'a\u02BE','\u1E9E':'ss','\u1F50':'\u03C5\u0313','\u1F52':'\u03C5\u0313\u0300','\u1F54':'\u03C5\u0313\u0301','\u1F56':'\u03C5\u0313\u0342','\u1F80':'\u1F00\u03B9','\u1F81':'\u1F01\u03B9','\u1F82':'\u1F02\u03B9','\u1F83':'\u1F03\u03B9','\u1F84':'\u1F04\u03B9','\u1F85':'\u1F05\u03B9','\u1F86':'\u1F06\u03B9','\u1F87':'\u1F07\u03B9','\u1F88':'\u1F00\u03B9','\u1F89':'\u1F01\u03B9','\u1F8A':'\u1F02\u03B9','\u1F8B':'\u1F03\u03B9','\u1F8C':'\u1F04\u03B9','\u1F8D':'\u1F05\u03B9','\u1F8E':'\u1F06\u03B9','\u1F8F':'\u1F07\u03B9','\u1F90':'\u1F20\u03B9','\u1F91':'\u1F21\u03B9','\u1F92':'\u1F22\u03B9','\u1F93':'\u1F23\u03B9','\u1F94':'\u1F24\u03B9','\u1F95':'\u1F25\u03B9','\u1F96':'\u1F26\u03B9','\u1F97':'\u1F27\u03B9','\u1F98':'\u1F20\u03B9','\u1F99':'\u1F21\u03B9','\u1F9A':'\u1F22\u03B9','\u1F9B':'\u1F23\u03B9','\u1F9C':'\u1F24\u03B9','\u1F9D':'\u1F25\u03B9','\u1F9E':'\u1F26\u03B9','\u1F9F':'\u1F27\u03B9','\u1FA0':'\u1F60\u03B9','\u1FA1':'\u1F61\u03B9','\u1FA2':'\u1F62\u03B9','\u1FA3':'\u1F63\u03B9','\u1FA4':'\u1F64\u03B9','\u1FA5':'\u1F65\u03B9','\u1FA6':'\u1F66\u03B9','\u1FA7':'\u1F67\u03B9','\u1FA8':'\u1F60\u03B9','\u1FA9':'\u1F61\u03B9','\u1FAA':'\u1F62\u03B9','\u1FAB':'\u1F63\u03B9','\u1FAC':'\u1F64\u03B9','\u1FAD':'\u1F65\u03B9','\u1FAE':'\u1F66\u03B9','\u1FAF':'\u1F67\u03B9','\u1FB2':'\u1F70\u03B9','\u1FB3':'\u03B1\u03B9','\u1FB4':'\u03AC\u03B9','\u1FB6':'\u03B1\u0342','\u1FB7':'\u03B1\u0342\u03B9','\u1FBC':'\u03B1\u03B9','\u1FC2':'\u1F74\u03B9','\u1FC3':'\u03B7\u03B9','\u1FC4':'\u03AE\u03B9','\u1FC6':'\u03B7\u0342','\u1FC7':'\u03B7\u0342\u03B9','\u1FCC':'\u03B7\u03B9','\u1FD2':'\u03B9\u0308\u0300','\u1FD3':'\u03B9\u0308\u0301','\u1FD6':'\u03B9\u0342','\u1FD7':'\u03B9\u0308\u0342','\u1FE2':'\u03C5\u0308\u0300','\u1FE3':'\u03C5\u0308\u0301','\u1FE4':'\u03C1\u0313','\u1FE6':'\u03C5\u0342','\u1FE7':'\u03C5\u0308\u0342','\u1FF2':'\u1F7C\u03B9','\u1FF3':'\u03C9\u03B9','\u1FF4':'\u03CE\u03B9','\u1FF6':'\u03C9\u0342','\u1FF7':'\u03C9\u0342\u03B9','\u1FFC':'\u03C9\u03B9','\uFB00':'ff','\uFB01':'fi','\uFB02':'fl','\uFB03':'ffi','\uFB04':'ffl','\uFB05':'st','\uFB06':'st','\uFB13':'\u0574\u0576','\uFB14':'\u0574\u0565','\uFB15':'\u0574\u056B','\uFB16':'\u057E\u0576','\uFB17':'\u0574\u056D'};

// Normalize reference label: collapse internal whitespace
// to single space, remove leading/trailing whitespace, case fold.
module.exports = function(string) {
    return string.trim().replace(regex, function($0) {
        // Note: there is no need to check `hasOwnProperty($0)` here.
        // If character not found in lookup table, it must be whitespace.
        return map[$0] || ' ';
    });
};

},{}],10:[function(require,module,exports){
"use strict";

var escapeXml = require('./common').escapeXml;

// Helper function to produce an XML tag.
var tag = function(name, attrs, selfclosing) {
    var result = '<' + name;
    if (attrs && attrs.length > 0) {
        var i = 0;
        var attrib;
        while ((attrib = attrs[i]) !== undefined) {
            result += ' ' + attrib[0] + '="' + attrib[1] + '"';
            i++;
        }
    }
    if (selfclosing) {
        result += ' /';
    }

    result += '>';
    return result;
};

var reXMLTag = /\<[^>]*\>/;

var toTagName = function(s) {
    return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
};

var renderNodes = function(block) {

    var attrs;
    var tagname;
    var walker = block.walker();
    var event, node, entering;
    var buffer = "";
    var lastOut = "\n";
    var disableTags = 0;
    var indentLevel = 0;
    var indent = '  ';
    var unescapedContents;
    var container;
    var selfClosing;
    var nodetype;

    var out = function(s) {
        if (disableTags > 0) {
            buffer += s.replace(reXMLTag, '');
        } else {
            buffer += s;
        }
        lastOut = s;
    };
    var esc = this.escape;
    var cr = function() {
        if (lastOut !== '\n') {
            buffer += '\n';
            lastOut = '\n';
            for (var i = indentLevel; i--;) {
                buffer += indent;
            }
        }
    };

    var options = this.options;

    if (options.time) { console.time("rendering"); }

    buffer += '<?xml version="1.0" encoding="UTF-8"?>\n';
    buffer += '<!DOCTYPE CommonMark SYSTEM "CommonMark.dtd">\n';

    while ((event = walker.next())) {
        entering = event.entering;
        node = event.node;
        nodetype = node.type;

        container = node.isContainer();
        selfClosing = nodetype === 'HorizontalRule' || nodetype === 'Hardbreak' ||
            nodetype === 'Softbreak' || nodetype === 'Image';
        unescapedContents = nodetype === 'Html' || nodetype === 'HtmlInline';
        tagname = toTagName(nodetype);

        if (entering) {

            attrs = [];

            switch (nodetype) {
            case 'List':
                if (node.listType !== null) {
                    attrs.push(['type', node.listType.toLowerCase()]);
                }
                if (node.listStart !== null) {
                    attrs.push(['start', String(node.listStart)]);
                }
                if (node.listTight !== null) {
                    attrs.push(['tight', (node.listTight ? 'true' : 'false')]);
                }
                var delim = node.listDelimiter;
                if (delim !== null) {
                    var delimword = '';
                    if (delim === '.') {
                        delimword = 'period';
                    } else {
                        delimword = 'paren';
                    }
                    attrs.push(['delimiter', delimword]);
                }
                break;
            case 'CodeBlock':
                if (node.info) {
                    attrs.push(['info', node.info]);
                }
                break;
            case 'Header':
                attrs.push(['level', String(node.level)]);
                break;
            case 'Link':
            case 'Image':
                attrs.push(['destination', node.destination]);
                attrs.push(['title', node.title]);
                break;
            default:
                break;
            }
            if (options.sourcepos) {
                var pos = node.sourcepos;
                if (pos) {
                    attrs.push(['sourcepos', String(pos[0][0]) + ':' +
                                String(pos[0][1]) + '-' + String(pos[1][0]) + ':' +
                                String(pos[1][1])]);
                }
            }

            cr();
            out(tag(tagname, attrs, selfClosing));
            if (container) {
                indentLevel += 1;
            } else if (!container && !selfClosing) {
                var lit = node.literal;
                if (lit) {
                    out(unescapedContents ? lit : esc(lit));
                }
                out(tag('/' + tagname));
            }
        } else {
            indentLevel -= 1;
            cr();
            out(tag('/' + tagname));
        }


    }
    if (options.time) { console.timeEnd("rendering"); }
    buffer += '\n';
    return buffer;
};

// The XmlRenderer object.
function XmlRenderer(options){
    return {
        // default options:
        softbreak: '\n', // by default, soft breaks are rendered as newlines in HTML
        // set to "<br />" to make them hard breaks
        // set to " " if you want to ignore line wrapping in source
        escape: escapeXml,
        options: options || {},
        render: renderNodes
    };
}

module.exports = XmlRenderer;

},{"./common":2}]},{},[6])(6)
});