text: 'use strict'
  
  module.exports = toHast
  
  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')
  
  var own = {}.hasOwnProperty
  
  // Factory to transform.
  function factory(tree, options) {
    var settings = options || {}
    var dangerous = settings.allowDangerousHTML
    var footnoteById = {}
  
    h.dangerous = dangerous
    h.definition = definitions(tree, settings)
    h.footnoteById = footnoteById
    h.footnoteOrder = []
    h.augment = augment
    h.handlers = Object.assign({}, handlers, settings.handlers)
  
    visit(tree, 'footnoteDefinition', onfootnotedefinition)
  
    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, `data.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 = Object.assign({}, 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 `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 onfootnotedefinition(definition) {
      var id = String(definition.identifier).toUpperCase()
  
      // Mimick CM behavior of link definitions.
      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8d48e57/index.js#L26>.
      if (!own.call(footnoteById, id)) {
        footnoteById[id] = 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 foot = footer(h)
  
    if (foot) {
      node.children = node.children.concat(u('text', '\n'), foot)
    }
  
    return node
  }
  