planning

node_modules/mdast-util-to-hast/lib/all.js

@@ -0,0 +1,37 @@
+'use strict'
+
+module.exports = all
+
+var trim = require('trim')
+var one = require('./one')
+
+function all(h, parent) {
+  var nodes = parent.children || []
+  var length = nodes.length
+  var values = []
+  var index = -1
+  var result
+  var head
+
+  while (++index < length) {
+    result = one(h, nodes[index], parent)
+
+    if (result) {
+      if (index && nodes[index - 1].type === 'break') {
+        if (result.value) {
+          result.value = trim.left(result.value)
+        }
+
+        head = result.children && result.children[0]
+
+        if (head && head.value) {
+          head.value = trim.left(head.value)
+        }
+      }
+
+      values = values.concat(result)
+    }
+  }
+
+  return values
+}

node_modules/mdast-util-to-hast/lib/footer.js

@@ -0,0 +1,61 @@
+'use strict'
+
+module.exports = generateFootnotes
+
+var thematicBreak = require('./handlers/thematic-break')
+var list = require('./handlers/list')
+var wrap = require('./wrap')
+
+function generateFootnotes(h) {
+  var footnotes = h.footnotes
+  var length = footnotes.length
+  var index = -1
+  var listItems = []
+  var def
+  var backReference
+  var content
+  var tail
+
+  if (!length) {
+    return null
+  }
+
+  while (++index < length) {
+    def = footnotes[index]
+    content = def.children.concat()
+    tail = content[content.length - 1]
+    backReference = {
+      type: 'link',
+      url: '#fnref-' + def.identifier,
+      data: {hProperties: {className: ['footnote-backref']}},
+      children: [{type: 'text', value: '↩'}]
+    }
+
+    if (!tail || tail.type !== 'paragraph') {
+      tail = {type: 'paragraph', children: []}
+      content.push(tail)
+    }
+
+    tail.children.push(backReference)
+
+    listItems[index] = {
+      type: 'listItem',
+      data: {hProperties: {id: 'fn-' + def.identifier}},
+      children: content,
+      position: def.position
+    }
+  }
+
+  return h(
+    null,
+    'div',
+    {className: ['footnotes']},
+    wrap(
+      [
+        thematicBreak(h),
+        list(h, {type: 'list', ordered: true, children: listItems})
+      ],
+      true
+    )
+  )
+}

node_modules/mdast-util-to-hast/lib/handlers/blockquote.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = blockquote
+
+var wrap = require('../wrap')
+var all = require('../all')
+
+function blockquote(h, node) {
+  return h(node, 'blockquote', wrap(all(h, node), true))
+}

node_modules/mdast-util-to-hast/lib/handlers/break.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = hardBreak
+
+var u = require('unist-builder')
+
+function hardBreak(h, node) {
+  return [h(node, 'br'), u('text', '\n')]
+}

node_modules/mdast-util-to-hast/lib/handlers/code.js

@@ -0,0 +1,18 @@
+'use strict'
+
+module.exports = code
+
+var detab = require('detab')
+var u = require('unist-builder')
+
+function code(h, node) {
+  var value = node.value ? detab(node.value + '\n') : ''
+  var lang = node.lang && node.lang.match(/^[^ \t]+(?=[ \t]|$)/)
+  var props = {}
+
+  if (lang) {
+    props.className = ['language-' + lang]
+  }
+
+  return h(node.position, 'pre', [h(node, 'code', props, [u('text', value)])])
+}

node_modules/mdast-util-to-hast/lib/handlers/delete.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = strikethrough
+
+var all = require('../all')
+
+function strikethrough(h, node) {
+  return h(node, 'del', all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/emphasis.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = emphasis
+
+var all = require('../all')
+
+function emphasis(h, node) {
+  return h(node, 'em', all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js

@@ -0,0 +1,15 @@
+'use strict'
+
+module.exports = footnoteReference
+
+var u = require('unist-builder')
+
+function footnoteReference(h, node) {
+  var identifier = node.identifier
+
+  return h(node.position, 'sup', {id: 'fnref-' + identifier}, [
+    h(node, 'a', {href: '#fn-' + identifier, className: ['footnote-ref']}, [
+      u('text', identifier)
+    ])
+  ])
+}

node_modules/mdast-util-to-hast/lib/handlers/footnote.js

@@ -0,0 +1,36 @@
+'use strict'
+
+module.exports = footnote
+
+var footnoteReference = require('./footnote-reference')
+
+function footnote(h, node) {
+  var identifiers = []
+  var identifier = 1
+  var footnotes = h.footnotes
+  var length = footnotes.length
+  var index = -1
+
+  while (++index < length) {
+    identifiers[index] = footnotes[index].identifier
+  }
+
+  while (identifiers.indexOf(String(identifier)) !== -1) {
+    identifier++
+  }
+
+  identifier = String(identifier)
+
+  footnotes.push({
+    type: 'footnoteDefinition',
+    identifier: identifier,
+    children: [{type: 'paragraph', children: node.children}],
+    position: node.position
+  })
+
+  return footnoteReference(h, {
+    type: 'footnoteReference',
+    identifier: identifier,
+    position: node.position
+  })
+}

node_modules/mdast-util-to-hast/lib/handlers/heading.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = heading
+
+var all = require('../all')
+
+function heading(h, node) {
+  return h(node, 'h' + node.depth, all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/html.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = html
+
+var u = require('unist-builder')
+
+// Return either a `raw` node, in dangerous mode, or nothing.
+function html(h, node) {
+  return h.dangerous ? h.augment(node, u('raw', node.value)) : null
+}

node_modules/mdast-util-to-hast/lib/handlers/image-reference.js

@@ -0,0 +1,23 @@
+'use strict'
+
+module.exports = imageReference
+
+var normalize = require('mdurl/encode')
+var revert = require('../revert')
+
+function imageReference(h, node) {
+  var def = h.definition(node.identifier)
+  var props
+
+  if (!def) {
+    return revert(h, node)
+  }
+
+  props = {src: normalize(def.url || ''), alt: node.alt}
+
+  if (def.title !== null && def.title !== undefined) {
+    props.title = def.title
+  }
+
+  return h(node, 'img', props)
+}

node_modules/mdast-util-to-hast/lib/handlers/image.js

@@ -0,0 +1,15 @@
+'use strict'
+
+var normalize = require('mdurl/encode')
+
+module.exports = image
+
+function image(h, node) {
+  var props = {src: normalize(node.url), alt: node.alt}
+
+  if (node.title !== null && node.title !== undefined) {
+    props.title = node.title
+  }
+
+  return h(node, 'img', props)
+}

node_modules/mdast-util-to-hast/lib/handlers/index.js

@@ -0,0 +1,35 @@
+'use strict'
+
+module.exports = {
+  blockquote: require('./blockquote'),
+  break: require('./break'),
+  code: require('./code'),
+  delete: require('./delete'),
+  emphasis: require('./emphasis'),
+  footnoteReference: require('./footnote-reference'),
+  footnote: require('./footnote'),
+  heading: require('./heading'),
+  html: require('./html'),
+  imageReference: require('./image-reference'),
+  image: require('./image'),
+  inlineCode: require('./inline-code'),
+  linkReference: require('./link-reference'),
+  link: require('./link'),
+  listItem: require('./list-item'),
+  list: require('./list'),
+  paragraph: require('./paragraph'),
+  root: require('./root'),
+  strong: require('./strong'),
+  table: require('./table'),
+  text: require('./text'),
+  thematicBreak: require('./thematic-break'),
+  toml: ignore,
+  yaml: ignore,
+  definition: ignore,
+  footnoteDefinition: ignore
+}
+
+// Return nothing for nodes which are ignored.
+function ignore() {
+  return null
+}

node_modules/mdast-util-to-hast/lib/handlers/inline-code.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = inlineCode
+
+var collapse = require('collapse-white-space')
+var u = require('unist-builder')
+
+function inlineCode(h, node) {
+  return h(node, 'code', [u('text', collapse(node.value))])
+}

node_modules/mdast-util-to-hast/lib/handlers/link-reference.js

@@ -0,0 +1,24 @@
+'use strict'
+
+module.exports = linkReference
+
+var normalize = require('mdurl/encode')
+var revert = require('../revert')
+var all = require('../all')
+
+function linkReference(h, node) {
+  var def = h.definition(node.identifier)
+  var props
+
+  if (!def) {
+    return revert(h, node)
+  }
+
+  props = {href: normalize(def.url || '')}
+
+  if (def.title !== null && def.title !== undefined) {
+    props.title = def.title
+  }
+
+  return h(node, 'a', props, all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/link.js

@@ -0,0 +1,16 @@
+'use strict'
+
+var normalize = require('mdurl/encode')
+var all = require('../all')
+
+module.exports = link
+
+function link(h, node) {
+  var props = {href: normalize(node.url)}
+
+  if (node.title !== null && node.title !== undefined) {
+    props.title = node.title
+  }
+
+  return h(node, 'a', props, all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/list-item.js

@@ -0,0 +1,89 @@
+'use strict'
+
+module.exports = listItem
+
+var u = require('unist-builder')
+var wrap = require('../wrap')
+var all = require('../all')
+
+function listItem(h, node, parent) {
+  var children = node.children
+  var head = children[0]
+  var raw = all(h, node)
+  var loose = parent ? listLoose(parent) : listItemLoose(node)
+  var props = {}
+  var result
+  var container
+  var index
+  var length
+  var child
+
+  /* Tight lists should not render 'paragraph' nodes as 'p' tags */
+  if (loose) {
+    result = raw
+  } else {
+    result = []
+    length = raw.length
+    index = -1
+
+    while (++index < length) {
+      child = raw[index]
+
+      if (child.tagName === 'p') {
+        result = result.concat(child.children)
+      } else {
+        result.push(child)
+      }
+    }
+  }
+
+  if (typeof node.checked === 'boolean') {
+    if (loose && (!head || head.type !== 'paragraph')) {
+      result.unshift(h(null, 'p', []))
+    }
+
+    container = loose ? result[0].children : result
+
+    if (container.length !== 0) {
+      container.unshift(u('text', ' '))
+    }
+
+    container.unshift(
+      h(null, 'input', {
+        type: 'checkbox',
+        checked: node.checked,
+        disabled: true
+      })
+    )
+
+    // According to github-markdown-css, this class hides bullet.
+    props.className = ['task-list-item']
+  }
+
+  if (loose && result.length !== 0) {
+    result = wrap(result, true)
+  }
+
+  return h(node, 'li', props, result)
+}
+
+function listLoose(node) {
+  var loose = node.spread
+  var children = node.children
+  var length = children.length
+  var index = -1
+
+  while (!loose && ++index < length) {
+    loose = listItemLoose(children[index])
+  }
+
+  return loose
+}
+
+function listItemLoose(node) {
+  var spread = node.spread
+
+  return spread === undefined || spread === null
+    ? node.children.length > 1
+    : spread
+}

node_modules/mdast-util-to-hast/lib/handlers/list.js

@@ -0,0 +1,17 @@
+'use strict'
+
+module.exports = list
+
+var wrap = require('../wrap')
+var all = require('../all')
+
+function list(h, node) {
+  var props = {}
+  var name = node.ordered ? 'ol' : 'ul'
+
+  if (typeof node.start === 'number' && node.start !== 1) {
+    props.start = node.start
+  }
+
+  return h(node, name, props, wrap(all(h, node), true))
+}

node_modules/mdast-util-to-hast/lib/handlers/paragraph.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = paragraph
+
+var all = require('../all')
+
+function paragraph(h, node) {
+  return h(node, 'p', all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/root.js

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = root
+
+var u = require('unist-builder')
+var wrap = require('../wrap')
+var all = require('../all')
+
+function root(h, node) {
+  return h.augment(node, u('root', wrap(all(h, node))))
+}

node_modules/mdast-util-to-hast/lib/handlers/strong.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = strong
+
+var all = require('../all')
+
+function strong(h, node) {
+  return h(node, 'strong', all(h, node))
+}

node_modules/mdast-util-to-hast/lib/handlers/table.js

@@ -0,0 +1,53 @@
+'use strict'
+
+module.exports = table
+
+var position = require('unist-util-position')
+var wrap = require('../wrap')
+var all = require('../all')
+
+function table(h, node) {
+  var rows = node.children
+  var index = rows.length
+  var align = node.align
+  var alignLength = align.length
+  var result = []
+  var pos
+  var row
+  var out
+  var name
+  var cell
+
+  while (index--) {
+    row = rows[index].children
+    name = index === 0 ? 'th' : 'td'
+    pos = alignLength
+    out = []
+
+    while (pos--) {
+      cell = row[pos]
+      out[pos] = h(cell, name, {align: align[pos]}, cell ? all(h, cell) : [])
+    }
+
+    result[index] = h(rows[index], 'tr', wrap(out, true))
+  }
+
+  return h(
+    node,
+    'table',
+    wrap(
+      [
+        h(result[0].position, 'thead', wrap([result[0]], true)),
+        h(
+          {
+            start: position.start(result[1]),
+            end: position.end(result[result.length - 1])
+          },
+          'tbody',
+          wrap(result.slice(1), true)
+        )
+      ],
+      true
+    )
+  )
+}

node_modules/mdast-util-to-hast/lib/handlers/text.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = text
+
+var u = require('unist-builder')
+var trimLines = require('trim-lines')
+
+function text(h, node) {
+  return h.augment(node, u('text', trimLines(node.value)))
+}

node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js

@@ -0,0 +1,7 @@
+'use strict'
+
+module.exports = thematicBreak
+
+function thematicBreak(h, node) {
+  return h(node, 'hr')
+}

node_modules/mdast-util-to-hast/lib/index.js

@@ -0,0 +1,99 @@
+'use strict'
+
+module.exports = toHast
+
+var xtend = require('xtend')
+var u = require('unist-builder')
+var visit = require('unist-util-visit')
+var position = require('unist-util-position')
+var generated = require('unist-util-generated')
+var definitions = require('mdast-util-definitions')
+var one = require('./one')
+var footer = require('./footer')
+var handlers = require('./handlers')
+
+// Factory to transform.
+function factory(tree, options) {
+  var settings = options || {}
+  var dangerous = settings.allowDangerousHTML
+
+  h.dangerous = dangerous
+  h.definition = definitions(tree, settings)
+  h.footnotes = []
+  h.augment = augment
+  h.handlers = xtend(handlers, settings.handlers || {})
+
+  visit(tree, 'footnoteDefinition', visitor)
+
+  return h
+
+  // Finalise the created `right`, a hast node, from `left`, an mdast node.
+  function augment(left, right) {
+    var data
+    var ctx
+
+    // Handle `data.hName`, `data.hProperties, `hChildren`.
+    if (left && 'data' in left) {
+      data = left.data
+
+      if (right.type === 'element' && data.hName) {
+        right.tagName = data.hName
+      }
+
+      if (right.type === 'element' && data.hProperties) {
+        right.properties = xtend(right.properties, data.hProperties)
+      }
+
+      if (right.children && data.hChildren) {
+        right.children = data.hChildren
+      }
+    }
+
+    ctx = left && left.position ? left : {position: left}
+
+    if (!generated(ctx)) {
+      right.position = {
+        start: position.start(ctx),
+        end: position.end(ctx)
+      }
+    }
+
+    return right
+  }
+
+  // Create an element for a `node`.
+  function h(node, tagName, props, children) {
+    if (
+      (children === undefined || children === null) &&
+      typeof props === 'object' &&
+      'length' in props
+    ) {
+      children = props
+      props = {}
+    }
+
+    return augment(node, {
+      type: 'element',
+      tagName: tagName,
+      properties: props || {},
+      children: children || []
+    })
+  }
+
+  function visitor(definition) {
+    h.footnotes.push(definition)
+  }
+}
+
+// Transform `tree`, which is an mdast node, to a hast node.
+function toHast(tree, options) {
+  var h = factory(tree, options)
+  var node = one(h, tree)
+  var footnotes = footer(h)
+
+  if (node && node.children && footnotes) {
+    node.children = node.children.concat(u('text', '\n'), footnotes)
+  }
+
+  return node
+}

node_modules/mdast-util-to-hast/lib/one.js

@@ -0,0 +1,45 @@
+'use strict'
+
+module.exports = one
+
+var u = require('unist-builder')
+var all = require('./all')
+
+var own = {}.hasOwnProperty
+
+// Transform an unknown node.
+function unknown(h, node) {
+  if (text(node)) {
+    return h.augment(node, u('text', node.value))
+  }
+
+  return h(node, 'div', all(h, node))
+}
+
+// Visit a node.
+function one(h, node, parent) {
+  var type = node && node.type
+  var fn = own.call(h.handlers, type) ? h.handlers[type] : null
+
+  // Fail on non-nodes.
+  if (!type) {
+    throw new Error('Expected node, got `' + node + '`')
+  }
+
+  return (typeof fn === 'function' ? fn : unknown)(h, node, parent)
+}
+
+// Check if the node should be renderered a text node.
+function text(node) {
+  var data = node.data || {}
+
+  if (
+    own.call(data, 'hName') ||
+    own.call(data, 'hProperties') ||
+    own.call(data, 'hChildren')
+  ) {
+    return false
+  }
+
+  return 'value' in node
+}

node_modules/mdast-util-to-hast/lib/revert.js

@@ -0,0 +1,44 @@
+'use strict'
+
+module.exports = revert
+
+var u = require('unist-builder')
+var all = require('./all')
+
+// Return the content of a reference without definition as markdown.
+function revert(h, node) {
+  var subtype = node.referenceType
+  var suffix = ']'
+  var contents
+  var head
+  var tail
+
+  if (subtype === 'collapsed') {
+    suffix += '[]'
+  } else if (subtype === 'full') {
+    suffix += '[' + (node.label || node.identifier) + ']'
+  }
+
+  if (node.type === 'imageReference') {
+    return u('text', '![' + node.alt + suffix)
+  }
+
+  contents = all(h, node)
+  head = contents[0]
+
+  if (head && head.type === 'text') {
+    head.value = '[' + head.value
+  } else {
+    contents.unshift(u('text', '['))
+  }
+
+  tail = contents[contents.length - 1]
+
+  if (tail && tail.type === 'text') {
+    tail.value += suffix
+  } else {
+    contents.push(u('text', suffix))
+  }
+
+  return contents
+}

node_modules/mdast-util-to-hast/lib/wrap.js

@@ -0,0 +1,31 @@
+'use strict'
+
+module.exports = wrap
+
+var u = require('unist-builder')
+
+// Wrap `nodes` with newlines between each entry.  Optionally adds newlines at
+// the start and end.
+function wrap(nodes, loose) {
+  var result = []
+  var index = -1
+  var length = nodes.length
+
+  if (loose) {
+    result.push(u('text', '\n'))
+  }
+
+  while (++index < length) {
+    if (index) {
+      result.push(u('text', '\n'))
+    }
+
+    result.push(nodes[index])
+  }
+
+  if (loose && nodes.length !== 0) {
+    result.push(u('text', '\n'))
+  }
+
+  return result
+}