text: (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.toMarkdown = f()}})(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){
  /*
   * to-markdown - an HTML to Markdown converter
   *
   * Copyright 2011+, Dom Christie
   * Licenced under the MIT licence
   *
   */
  
  'use strict'
  
  var toMarkdown
  var converters
  var mdConverters = require('./lib/md-converters')
  var gfmConverters = require('./lib/gfm-converters')
  var HtmlParser = require('./lib/html-parser')
  var collapse = require('collapse-whitespace')
  
  /*
   * Utilities
   */
  
  var blocks = ['address', 'article', 'aside', 'audio', 'blockquote', 'body',
    'canvas', 'center', 'dd', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption',
    'figure', 'footer', 'form', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
    'header', 'hgroup', 'hr', 'html', 'isindex', 'li', 'main', 'menu', 'nav',
    'noframes', 'noscript', 'ol', 'output', 'p', 'pre', 'section', 'table',
    'tbody', 'td', 'tfoot', 'th', 'thead', 'tr', 'ul'
  ]
  
  function isBlock (node) {
    return blocks.indexOf(node.nodeName.toLowerCase()) !== -1
  }
  
  var voids = [
    'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input',
    'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'
  ]
  
  function isVoid (node) {
    return voids.indexOf(node.nodeName.toLowerCase()) !== -1
  }
  
  function htmlToDom (string) {
    var tree = new HtmlParser().parseFromString(string, 'text/html')
    collapse(tree.documentElement, isBlock)
    return tree
  }
  
  /*
   * Flattens DOM tree into single array
   */
  
  function bfsOrder (node) {
    var inqueue = [node]
    var outqueue = []
    var elem
    var children
    var i
  
    while (inqueue.length > 0) {
      elem = inqueue.shift()
      outqueue.push(elem)
      children = elem.childNodes
      for (i = 0; i < children.length; i++) {
        if (children[i].nodeType === 1) inqueue.push(children[i])
      }
    }
    outqueue.shift()
    return outqueue
  }
  
  /*
   * Contructs a Markdown string of replacement text for a given node
   */
  
  function getContent (node) {
    var text = ''
    for (var i = 0; i < node.childNodes.length; i++) {
      if (node.childNodes[i].nodeType === 1) {
        text += node.childNodes[i]._replacement
      } else if (node.childNodes[i].nodeType === 3) {
        text += node.childNodes[i].data
      } else continue
    }
    return text
  }
  
  /*
   * Returns the HTML string of an element with its contents converted
   */
  
  function outer (node, content) {
    return node.cloneNode(false).outerHTML.replace('><', '>' + content + '<')
  }
  
  function canConvert (node, filter) {
    if (typeof filter === 'string') {
      return filter === node.nodeName.toLowerCase()
    }
    if (Array.isArray(filter)) {
      return filter.indexOf(node.nodeName.toLowerCase()) !== -1
    } else if (typeof filter === 'function') {
      return filter.call(toMarkdown, node)
    } else {
      throw new TypeError('`filter` needs to be a string, array, or function')
    }
  }
  
  function isFlankedByWhitespace (side, node) {
    var sibling
    var regExp
    var isFlanked
  
    if (side === 'left') {
      sibling = node.previousSibling
      regExp = / $/
    } else {
      sibling = node.nextSibling
      regExp = /^ /
    }
  
    if (sibling) {
      if (sibling.nodeType === 3) {
        isFlanked = regExp.test(sibling.nodeValue)
      } else if (sibling.nodeType === 1 && !isBlock(sibling)) {
        isFlanked = regExp.test(sibling.textContent)
      }
    }
    return isFlanked
  }
  
  function flankingWhitespace (node, content) {
    var leading = ''
    var trailing = ''
  
    if (!isBlock(node)) {
      var hasLeading = /^[ \r\n\t]/.test(content)
      var hasTrailing = /[ \r\n\t]$/.test(content)
  
      if (hasLeading && !isFlankedByWhitespace('left', node)) {
        leading = ' '
      }
      if (hasTrailing && !isFlankedByWhitespace('right', node)) {
        trailing = ' '
      }
    }
  
    return { leading: leading, trailing: trailing }
  }
  
  /*
   * Finds a Markdown converter, gets the replacement, and sets it on
   * `_replacement`
   */
  
  function process (node) {
    var replacement
    var content = getContent(node)
  
    // Remove blank nodes
    if (!isVoid(node) && !/A|TH|TD/.test(node.nodeName) && /^\s*$/i.test(content)) {
      node._replacement = ''
      return
    }
  
    for (var i = 0; i < converters.length; i++) {
      var converter = converters[i]
  
      if (canConvert(node, converter.filter)) {
        if (typeof converter.replacement !== 'function') {
          throw new TypeError(
            '`replacement` needs to be a function that returns a string'
          )
        }
  
        var whitespace = flankingWhitespace(node, content)
  
        if (whitespace.leading || whitespace.trailing) {
          content = content.trim()
        }
        replacement = whitespace.leading +
          converter.replacement.call(toMarkdown, content, node) +
          whitespace.trailing
        break
      }
    }
  
    node._replacement = replacement
  }
  
  toMarkdown = function (input, options) {
    options = options || {}
  
    if (typeof input !== 'string') {
      throw new TypeError(input + ' is not a string')
    }
  
    if (input === '') {
      return ''
    }
  
    // Escape potential ol triggers
    input = input.replace(/(\d+)\. /g, '$1\\. ')
  
    var clone = htmlToDom(input).body
    var nodes = bfsOrder(clone)
    var output
  
    converters = mdConverters.slice(0)
    if (options.gfm) {
      converters = gfmConverters.concat(converters)
    }
  
    if (options.converters) {
      converters = options.converters.concat(converters)
    }
  
    // Process through nodes in reverse (so deepest child elements are first).
    for (var i = nodes.length - 1; i >= 0; i--) {
      process(nodes[i])
    }
    output = getContent(clone)
  
    return output.replace(/^[\t\r\n]+|[\t\r\n\s]+$/g, '')
      .replace(/\n\s+\n/g, '\n\n')
      .replace(/\n{3,}/g, '\n\n')
  }
  
  toMarkdown.isBlock = isBlock
  toMarkdown.isVoid = isVoid
  toMarkdown.outer = outer
  
  module.exports = toMarkdown
  
  },{"./lib/gfm-converters":2,"./lib/html-parser":3,"./lib/md-converters":4,"collapse-whitespace":6}],2:[function(require,module,exports){
  'use strict'
  
  function cell (content, node) {
    var index = Array.prototype.indexOf.call(node.parentNode.childNodes, node)
    var prefix = ' '
    if (index === 0) prefix = '| '
    return prefix + content + ' |'
  }
  
  var highlightRegEx = /highlight highlight-(\S+)/
  
  module.exports = [
    {
      filter: 'br',
      replacement: function () {
        return '\n'
      }
    },
    {
      filter: ['del', 's', 'strike'],
      replacement: function (content) {
        return '~~' + content + '~~'
      }
    },
  
    {
      filter: function (node) {
        return node.type === 'checkbox' && node.parentNode.nodeName === 'LI'
      },
      replacement: function (content, node) {
        return (node.checked ? '[x]' : '[ ]') + ' '
      }
    },
  
    {
      filter: ['th', 'td'],
      replacement: function (content, node) {
        return cell(content, node)
      }
    },
  
    {
      filter: 'tr',
      replacement: function (content, node) {
        var borderCells = ''
        var alignMap = { left: ':--', right: '--:', center: ':-:' }
  
        if (node.parentNode.nodeName === 'THEAD') {
          for (var i = 0; i < node.childNodes.length; i++) {
            var align = node.childNodes[i].attributes.align
            var border = '---'
  
            if (align) border = alignMap[align.value] || border
  
            borderCells += cell(border, node.childNodes[i])
          }
        }
        return '\n' + content + (borderCells ? '\n' + borderCells : '')
      }
    },
  
    {
      filter: 'table',
      replacement: function (content) {
        return '\n\n' + content + '\n\n'
      }
    },
  
    {
      filter: ['thead', 'tbody', 'tfoot'],
      replacement: function (content) {
        return content
      }
    },
  
    // Fenced code blocks
    {
      filter: function (node) {
        return node.nodeName === 'PRE' &&
        node.firstChild &&
        node.firstChild.nodeName === 'CODE'
      },
      replacement: function (content, node) {
        return '\n\n```\n' + node.firstChild.textContent + '\n```\n\n'
      }
    },
  
    // Syntax-highlighted code blocks
    {
      filter: function (node) {
        return node.nodeName === 'PRE' &&
        node.parentNode.nodeName === 'DIV' &&
        highlightRegEx.test(node.parentNode.className)
      },
      replacement: function (content, node) {
        var language = node.parentNode.className.match(highlightRegEx)[1]
        return '\n\n```' + language + '\n' + node.textContent + '\n```\n\n'
      }
    },
  
    {
      filter: function (node) {
        return node.nodeName === 'DIV' &&
        highlightRegEx.test(node.className)
      },
      replacement: function (content) {
        return '\n\n' + content + '\n\n'
      }
    }
  ]
  
  },{}],3:[function(require,module,exports){
  /*
   * Set up window for Node.js
   */
  
  var _window = (typeof window !== 'undefined' ? window : this)
  
  /*
   * Parsing HTML strings
   */
  
  function canParseHtmlNatively () {
    var Parser = _window.DOMParser
    var canParse = false
  
    // Adapted from https://gist.github.com/1129031
    // Firefox/Opera/IE throw errors on unsupported types
    try {
      // WebKit returns null on unsupported types
      if (new Parser().parseFromString('', 'text/html')) {
        canParse = true
      }
    } catch (e) {}
  
    return canParse
  }
  
  function createHtmlParser () {
    var Parser = function () {}
  
    // For Node.js environments
    if (typeof document === 'undefined') {
      var jsdom = require('jsdom')
      Parser.prototype.parseFromString = function (string) {
        return jsdom.jsdom(string, {
          features: {
            FetchExternalResources: [],
            ProcessExternalResources: false
          }
        })
      }
    } else {
      if (!shouldUseActiveX()) {
        Parser.prototype.parseFromString = function (string) {
          var doc = document.implementation.createHTMLDocument('')
          doc.open()
          doc.write(string)
          doc.close()
          return doc
        }
      } else {
        Parser.prototype.parseFromString = function (string) {
          var doc = new window.ActiveXObject('htmlfile')
          doc.designMode = 'on' // disable on-page scripts
          doc.open()
          doc.write(string)
          doc.close()
          return doc
        }
      }
    }
    return Parser
  }
  
  function shouldUseActiveX () {
    var useActiveX = false
  
    try {
      document.implementation.createHTMLDocument('').open()
    } catch (e) {
      if (window.ActiveXObject) useActiveX = true
    }
  
    return useActiveX
  }
  
  module.exports = canParseHtmlNatively() ? _window.DOMParser : createHtmlParser()
  
  },{"jsdom":5}],4:[function(require,module,exports){
  'use strict'
  
  module.exports = [
    {
      filter: 'p',
      replacement: function (content) {
        return '\n\n' + content + '\n\n'
      }
    },
  
    {
      filter: 'br',
      replacement: function () {
        return '  \n'
      }
    },
  
    {
      filter: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
      replacement: function (content, node) {
        var hLevel = node.nodeName.charAt(1)
        var hPrefix = ''
        for (var i = 0; i < hLevel; i++) {
          hPrefix += '#'
        }
        return '\n\n' + hPrefix + ' ' + content + '\n\n'
      }
    },
  
    {
      filter: 'hr',
      replacement: function () {
        return '\n\n* * *\n\n'
      }
    },
  
    {
      filter: ['em', 'i'],
      replacement: function (content) {
        return '_' + content + '_'
      }
    },
  
    {
      filter: ['strong', 'b'],
      replacement: function (content) {
        return '**' + content + '**'
      }
    },
  
    // Inline code
    {
      filter: function (node) {
        var hasSiblings = node.previousSibling || node.nextSibling
        var isCodeBlock = node.parentNode.nodeName === 'PRE' && !hasSiblings
  
        return node.nodeName === 'CODE' && !isCodeBlock
      },
      replacement: function (content) {
        return '`' + content + '`'
      }
    },
  
    {
      filter: function (node) {
        return node.nodeName === 'A' && node.getAttribute('href')
      },
      replacement: function (content, node) {
        var titlePart = node.title ? ' "' + node.title + '"' : ''
        return '[' + content + '](' + node.getAttribute('href') + titlePart + ')'
      }
    },
  
    {
      filter: 'img',
      replacement: function (content, node) {
        var alt = node.alt || ''
        var src = node.getAttribute('src') || ''
        var title = node.title || ''
        var titlePart = title ? ' "' + title + '"' : ''
        return src ? '![' + alt + ']' + '(' + src + titlePart + ')' : ''
      }
    },
  
    // Code blocks
    {
      filter: function (node) {
        return node.nodeName === 'PRE' && node.firstChild.nodeName === 'CODE'
      },
      replacement: function (content, node) {
        return '\n\n    ' + node.firstChild.textContent.replace(/\n/g, '\n    ') + '\n\n'
      }
    },
  
    {
      filter: 'blockquote',
      replacement: function (content) {
        content = content.trim()
        content = content.replace(/\n{3,}/g, '\n\n')
        content = content.replace(/^/gm, '> ')
        return '\n\n' + content + '\n\n'
      }
    },
  
    {
      filter: 'li',
      replacement: function (content, node) {
        content = content.replace(/^\s+/, '').replace(/\n/gm, '\n    ')
        var prefix = '*   '
        var parent = node.parentNode
        if (parent.nodeName === 'OL') {
          var start = parent.getAttribute('start')
          var index = Array.prototype.indexOf.call(parent.children, node)
          prefix = (start ? Number(start) + index : index + 1) + '.  '
        }
  
        return prefix + content
      }
    },
  
    {
      filter: ['ul', 'ol'],
      replacement: function (content, node) {
        var strings = []
        for (var i = 0; i < node.childNodes.length; i++) {
          strings.push(node.childNodes[i]._replacement)
        }
  
        if (/li/i.test(node.parentNode.nodeName)) {
          return '\n' + strings.join('\n')
        }
        return '\n\n' + strings.join('\n') + '\n\n'
      }
    },
  
    {
      filter: function (node) {
        return this.isBlock(node)
      },
      replacement: function (content, node) {
        return '\n\n' + this.outer(node, content) + '\n\n'
      }
    },
  
    // Anything else!
    {
      filter: function () {
        return true
      },
      replacement: function (content, node) {
        return this.outer(node, content)
      }
    }
  ]
  
  },{}],5:[function(require,module,exports){
  
  },{}],6:[function(require,module,exports){
  'use strict';
  
  var voidElements = require('void-elements');
  Object.keys(voidElements).forEach(function (name) {
    voidElements[name.toUpperCase()] = 1;
  });
  
  var blockElements = {};
  require('block-elements').forEach(function (name) {
    blockElements[name.toUpperCase()] = 1;
  });
  
  /**
   * isBlockElem(node) determines if the given node is a block element.
   *
   * @param {Node} node
   * @return {Boolean}
   */
  function isBlockElem(node) {
    return !!(node && blockElements[node.nodeName]);
  }
  
  /**
   * isPreElem(node) determines if the given node is a PRE element.
   * 
   * Whitespace for PRE elements are not collapsed.
   * 
   * @param {Node} node
   * @return {Boolean}
   */
  function isPreElem(node) {
    return node.nodeName === 'PRE';
  }
  
  /**
   * isVoid(node) determines if the given node is a void element.
   *
   * @param {Node} node
   * @return {Boolean}
   */
  function isVoid(node) {
    return !!(node && voidElements[node.nodeName]);
  }
  
  /**
   * whitespace(elem [, isBlock]) removes extraneous whitespace from an
   * the given element. The function isBlock may optionally be passed in
   * to determine whether or not an element is a block element; if none
   * is provided, defaults to using the list of block elements provided
   * by the `block-elements` module.
   *
   * @param {Node} elem
   * @param {Function} blockTest
   */
  function collapseWhitespace(elem, isBlock, isPre) {
    if (!elem.firstChild || elem.nodeName === 'PRE') return;
  
    if (typeof isBlock !== 'function') {
      isBlock = isBlockElem;
    }
  
    if (typeof isPre !== 'function') {
      isPre = isPreElem;
    }
  
    var prevText = null;
    var prevVoid = false;
  
    var prev = null;
    var node = next(prev, elem, isPre);
  
    while (node !== elem) {
      if (node.nodeType === 3 || node.nodeType === 4) {
        // Node.TEXT_NODE or Node.CDATA_SECTION_NODE
        var text = node.data;
  
        if ((!prevText || / $/.test(prevText.data)) && !prevVoid && text[0] === ' ') {
          text = text.substr(1);
        }
  
        // `text` might be empty at this point.
        if (!text) {
          node = remove(node);
          continue;
        }
  
        node.data = text;
  
        prevText = node;
      } else if (node.nodeType === 1) {
        // Node.ELEMENT_NODE
        if (isBlock(node) || node.nodeName === 'BR') {
          if (prevText) {
            prevText.data = prevText.data.replace(/ $/, '');
          }
  
          prevText = null;
          prevVoid = false;
        } else if (isVoid(node)) {
          // Avoid trimming space around non-block, non-BR void elements.
          prevText = null;
          prevVoid = true;
        }
      } else {
        node = remove(node);
        continue;
      }
  
      var nextNode = next(prev, node, isPre);
      prev = node;
      node = nextNode;
    }
  
    if (prevText) {
      prevText.data = prevText.data.replace(/ $/, '');
      if (!prevText.data) {
        remove(prevText);
      }
    }
  }
  
  /**
   * remove(node) removes the given node from the DOM and returns the
   * next node in the sequence.
   *
   * @param {Node} node
   * @return {Node} node
   */
  function remove(node) {
    var next = node.nextSibling || node.parentNode;
  
    node.parentNode.removeChild(node);
  
    return next;
  }
  
  /**
   * next(prev, current, isPre) returns the next node in the sequence, given the
   * current and previous nodes.
   *
   * @param {Node} prev
   * @param {Node} current
   * @param {Function} isPre
   * @return {Node}
   */
  function next(prev, current, isPre) {
    if (prev && prev.parentNode === current || isPre(current)) {
      return current.nextSibling || current.parentNode;
    }
  
    return current.firstChild || current.nextSibling || current.parentNode;
  }
  
  module.exports = collapseWhitespace;
  
  },{"block-elements":7,"void-elements":8}],7:[function(require,module,exports){
  /**
   * This file automatically generated from `build.js`.
   * Do not manually edit.
   */
  
  module.exports = [
    "address",
    "article",
    "aside",
    "blockquote",
    "canvas",
    "dd",
    "div",
    "dl",
    "dt",
    "fieldset",
    "figcaption",
    "figure",
    "footer",
    "form",
    "h1",
    "h2",
    "h3",
    "h4",
    "h5",
    "h6",
    "header",
    "hgroup",
    "hr",
    "li",
    "main",
    "nav",
    "noscript",
    "ol",
    "output",
    "p",
    "pre",
    "section",
    "table",
    "tfoot",
    "ul",
    "video"
  ];
  
  },{}],8:[function(require,module,exports){
  /**
   * This file automatically generated from `pre-publish.js`.
   * Do not manually edit.
   */
  
  module.exports = {
    "area": true,
    "base": true,
    "br": true,
    "col": true,
    "embed": true,
    "hr": true,
    "img": true,
    "input": true,
    "keygen": true,
    "link": true,
    "menuitem": true,
    "meta": true,
    "param": true,
    "source": true,
    "track": true,
    "wbr": true
  };
  
  },{}]},{},[1])(1)
  });