(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){if(!t){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={exports:{}};t[0].call(l.exports,function(e){var n=t[1];return s(n?n:e)},l,l.exports,e,t,n,r)}return n.exports}var i=typeof require==“function”&&require;for(var o=0;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) {

var leading = ''
var trailing = ''

if (!isBlock(node)) {
  var hasLeading = /^[ \r\n\t]/.test(node.innerHTML)
  var hasTrailing = /[ \r\n\t]$/.test(node.innerHTML)

  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)

    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')
}

// 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”:7}],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”:6}],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
    var index = Array.prototype.indexOf.call(parent.children, node) + 1

    prefix = /ol/i.test(parent.nodeName) ? index + '.  ' : '*   '
    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){ /**

* This file automatically generated from `build.js`.
* Do not manually edit.
*/

module.exports = [

"address",
"article",
"aside",
"audio",
"blockquote",
"canvas",
"dd",
"div",
"dl",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"header",
"hgroup",
"hr",
"main",
"nav",
"noscript",
"ol",
"output",
"p",
"pre",
"section",
"table",
"tfoot",
"ul",
"video"

];

},{}],6:[function(require,module,exports){

},{}],7:[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]);

}

/**

* 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) {

if (!elem.firstChild || elem.nodeName === 'PRE') return;

if (typeof isBlock !== 'function') {
  isBlock = isBlockElem;
}

var prevText = null;
var prevVoid = false;

var prev = null;
var node = next(prev, elem);

while (node !== elem) {
  if (node.nodeType === 3) {
    // Node.TEXT_NODE
    var text = node.data.replace(/[ \r\n\t]+/g, ' ');

    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);
  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) returns the next node in the sequence, given the
* current and previous nodes.
*
* @param {Node} prev
* @param {Node} current
* @return {Node}
*/

function next(prev, current) {

if (prev && prev.parentNode === current || current.nodeName === 'PRE') {
  return current.nextSibling || current.parentNode;
}

return current.firstChild || current.nextSibling || current.parentNode;

}

module.exports = collapseWhitespace;

},{“block-elements”:5,“void-elements”:8}],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) });