text: 'use strict';
  
  var typeOf = require('kind-of');
  var utils = module.exports;
  
  /**
   * Returns true if the given value is a node.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var node = new Node({type: 'foo'});
   * console.log(utils.isNode(node)); //=> true
   * console.log(utils.isNode({})); //=> false
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @returns {Boolean}
   * @api public
   */
  
  utils.isNode = function(node) {
    return typeOf(node) === 'object' && node.isNode === true;
  };
  
  /**
   * Emit an empty string for the given `node`.
   *
   * ```js
   * // do nothing for beginning-of-string
   * snapdragon.compiler.set('bos', utils.noop);
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @returns {undefined}
   * @api public
   */
  
  utils.noop = function(node) {
    append(this, '', node);
  };
  
  /**
   * Returns `node.value` or `node.val`.
   *
   * ```js
   * const star = new Node({type: 'star', value: '*'});
   * const slash = new Node({type: 'slash', val: '/'});
   * console.log(utils.value(star)) //=> '*'
   * console.log(utils.value(slash)) //=> '/'
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @returns {String} returns
   * @api public
   */
  
  utils.value = function(node) {
    if (typeof node.value === 'string') {
      return node.value;
    }
    return node.val;
  };
  
  /**
   * Append `node.value` to `compiler.output`.
   *
   * ```js
   * snapdragon.compiler.set('text', utils.identity);
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @returns {undefined}
   * @api public
   */
  
  utils.identity = function(node) {
    append(this, utils.value(node), node);
  };
  
  /**
   * Previously named `.emit`, this method appends the given `value`
   * to `compiler.output` for the given node. Useful when you know
   * what value should be appended advance, regardless of the actual
   * value of `node.value`.
   *
   * ```js
   * snapdragon.compiler
   *   .set('i', function(node) {
   *     this.mapVisit(node);
   *   })
   *   .set('i.open', utils.append('<i>'))
   *   .set('i.close', utils.append('</i>'))
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @returns {Function} Returns a compiler middleware function.
   * @api public
   */
  
  utils.append = function(value) {
    return function(node) {
      append(this, value, node);
    };
  };
  
  /**
   * Used in compiler middleware, this onverts an AST node into
   * an empty `text` node and deletes `node.nodes` if it exists.
   * The advantage of this method is that, as opposed to completely
   * removing the node, indices will not need to be re-calculated
   * in sibling nodes, and nothing is appended to the output.
   *
   * ```js
   * utils.toNoop(node);
   * // convert `node.nodes` to the given value instead of deleting it
   * utils.toNoop(node, []);
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Array} `nodes` Optionally pass a new `nodes` value, to replace the existing `node.nodes` array.
   * @api public
   */
  
  utils.toNoop = function(node, nodes) {
    if (nodes) {
      node.nodes = nodes;
    } else {
      delete node.nodes;
      node.type = 'text';
      node.value = '';
    }
  };
  
  /**
   * Visit `node` with the given `fn`. The built-in `.visit` method in snapdragon
   * automatically calls registered compilers, this allows you to pass a visitor
   * function.
   *
   * ```js
   * snapdragon.compiler.set('i', function(node) {
   *   utils.visit(node, function(childNode) {
   *     // do stuff with "childNode"
   *     return childNode;
   *   });
   * });
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Function} `fn`
   * @return {Object} returns the node after recursively visiting all child nodes.
   * @api public
   */
  
  utils.visit = function(node, fn) {
    assert(isFunction(fn), 'expected a visitor function');
    expect(node, 'node');
    fn(node);
    return node.nodes ? utils.mapVisit(node, fn) : node;
  };
  
  /**
   * Map [visit](#visit) the given `fn` over `node.nodes`. This is called by
   * [visit](#visit), use this method if you do not want `fn` to be called on
   * the first node.
   *
   * ```js
   * snapdragon.compiler.set('i', function(node) {
   *   utils.mapVisit(node, function(childNode) {
   *     // do stuff with "childNode"
   *     return childNode;
   *   });
   * });
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Object} `options`
   * @param {Function} `fn`
   * @return {Object} returns the node
   * @api public
   */
  
  utils.mapVisit = function(node, fn) {
    assert(isFunction(fn), 'expected a visitor function');
    expect(node, 'node');
    assert(isArray(node.nodes), 'expected node.nodes to be an array');
  
    for (var i = 0; i < node.nodes.length; i++) {
      utils.visit(node.nodes[i], fn);
    }
    return node;
  };
  
  /**
   * Unshift an `*.open` node onto `node.nodes`.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * snapdragon.parser.set('brace', function(node) {
   *   var match = this.match(/^{/);
   *   if (match) {
   *     var parent = new Node({type: 'brace'});
   *     utils.addOpen(parent, Node);
   *     console.log(parent.nodes[0]):
   *     // { type: 'brace.open', value: '' };
   *
   *     // push the parent "brace" node onto the stack
   *     this.push(parent);
   *
   *     // return the parent node, so it's also added to the AST
   *     return brace;
   *   }
   * });
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Function} `Node` (required) Node constructor function from [snapdragon-node][].
   * @param {Function} `filter` Optionaly specify a filter function to exclude the node.
   * @return {Object} Returns the created opening node.
   * @api public
   */
  
  utils.addOpen = function(node, Node, value, filter) {
    expect(node, 'node');
    assert(isFunction(Node), 'expected Node to be a constructor function');
  
    if (typeof value === 'function') {
      filter = value;
      value = '';
    }
  
    if (typeof filter === 'function' && !filter(node)) return;
    var open = new Node({ type: node.type + '.open', value: value});
    var unshift = node.unshift || node.unshiftNode;
    if (typeof unshift === 'function') {
      unshift.call(node, open);
    } else {
      utils.unshiftNode(node, open);
    }
    return open;
  };
  
  /**
   * Push a `*.close` node onto `node.nodes`.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * snapdragon.parser.set('brace', function(node) {
   *   var match = this.match(/^}/);
   *   if (match) {
   *     var parent = this.parent();
   *     if (parent.type !== 'brace') {
   *       throw new Error('missing opening: ' + '}');
   *     }
   *
   *     utils.addClose(parent, Node);
   *     console.log(parent.nodes[parent.nodes.length - 1]):
   *     // { type: 'brace.close', value: '' };
   *
   *     // no need to return a node, since the parent
   *     // was already added to the AST
   *     return;
   *   }
   * });
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Function} `Node` (required) Node constructor function from [snapdragon-node][].
   * @param {Function} `filter` Optionaly specify a filter function to exclude the node.
   * @return {Object} Returns the created closing node.
   * @api public
   */
  
  utils.addClose = function(node, Node, value, filter) {
    assert(isFunction(Node), 'expected Node to be a constructor function');
    expect(node, 'node', Node);
  
    if (typeof value === 'function') {
      filter = value;
      value = '';
    }
  
    if (typeof filter === 'function' && !filter(node)) return;
    var close = new Node({ type: node.type + '.close', value: value});
    var push = node.push || node.pushNode;
    if (typeof push === 'function') {
      push.call(node, close);
    } else {
      utils.pushNode(node, close);
    }
    return close;
  };
  
  /**
   * Wraps the given `node` with `*.open` and `*.close` nodes.
   *
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Function} `Node` (required) Node constructor function from [snapdragon-node][].
   * @param {Function} `filter` Optionaly specify a filter function to exclude the node.
   * @return {Object} Returns the node
   * @api public
   */
  
  utils.wrapNodes = function(node, Node, filter) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    assert(isFunction(Node), 'expected Node to be a constructor function');
  
    utils.addOpen(node, Node, filter);
    utils.addClose(node, Node, filter);
    return node;
  };
  
  /**
   * Push the given `node` onto `parent.nodes`, and set `parent` as `node.parent.
   *
   * ```js
   * var parent = new Node({type: 'foo'});
   * var node = new Node({type: 'bar'});
   * utils.pushNode(parent, node);
   * console.log(parent.nodes[0].type) // 'bar'
   * console.log(node.parent.type) // 'foo'
   * ```
   * @param {Object} `parent`
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Object} Returns the child node
   * @api public
   */
  
  utils.pushNode = function(parent, node) {
    assert(utils.isNode(parent), 'expected parent node to be an instance of Node');
    if (!node) return;
  
    if (typeof parent.push === 'function') {
      return parent.push(node);
    }
  
    node.define('parent', parent);
    parent.nodes = parent.nodes || [];
    parent.nodes.push(node);
    return node;
  };
  
  /**
   * Unshift `node` onto `parent.nodes`, and set `parent` as `node.parent.
   *
   * ```js
   * var parent = new Node({type: 'foo'});
   * var node = new Node({type: 'bar'});
   * utils.unshiftNode(parent, node);
   * console.log(parent.nodes[0].type) // 'bar'
   * console.log(node.parent.type) // 'foo'
   * ```
   * @param {Object} `parent`
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {undefined}
   * @api public
   */
  
  utils.unshiftNode = function(parent, node) {
    assert(utils.isNode(parent), 'expected parent node to be an instance of Node');
    if (!node) return;
  
    if (typeof parent.unshift === 'function') {
      return parent.unshift(node);
    }
  
    node.define('parent', parent);
    parent.nodes = parent.nodes || [];
    parent.nodes.unshift(node);
  };
  
  /**
   * Pop the last `node` off of `parent.nodes`. The advantage of
   * using this method is that it checks for `node.nodes` and works
   * with any version of `snapdragon-node`.
   *
   * ```js
   * var parent = new Node({type: 'foo'});
   * utils.pushNode(parent, new Node({type: 'foo'}));
   * utils.pushNode(parent, new Node({type: 'bar'}));
   * utils.pushNode(parent, new Node({type: 'baz'}));
   * console.log(parent.nodes.length); //=> 3
   * utils.popNode(parent);
   * console.log(parent.nodes.length); //=> 2
   * ```
   * @param {Object} `parent`
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Number|Undefined} Returns the length of `node.nodes` or undefined.
   * @api public
   */
  
  utils.popNode = function(node) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    if (typeof node.pop === 'function') {
      return node.pop();
    }
    return node.nodes && node.nodes.pop();
  };
  
  /**
   * Shift the first `node` off of `parent.nodes`. The advantage of
   * using this method is that it checks for `node.nodes` and works
   * with any version of `snapdragon-node`.
   *
   * ```js
   * var parent = new Node({type: 'foo'});
   * utils.pushNode(parent, new Node({type: 'foo'}));
   * utils.pushNode(parent, new Node({type: 'bar'}));
   * utils.pushNode(parent, new Node({type: 'baz'}));
   * console.log(parent.nodes.length); //=> 3
   * utils.shiftNode(parent);
   * console.log(parent.nodes.length); //=> 2
   * ```
   * @param {Object} `parent`
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Number|Undefined} Returns the length of `node.nodes` or undefined.
   * @api public
   */
  
  utils.shiftNode = function(node) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    if (typeof node.shift === 'function') {
      return node.shift();
    }
    return node.nodes && node.nodes.shift();
  };
  
  /**
   * Remove the specified `node` from `parent.nodes`.
   *
   * ```js
   * var parent = new Node({type: 'abc'});
   * var foo = new Node({type: 'foo'});
   * utils.pushNode(parent, foo);
   * utils.pushNode(parent, new Node({type: 'bar'}));
   * utils.pushNode(parent, new Node({type: 'baz'}));
   * console.log(parent.nodes.length); //=> 3
   * utils.removeNode(parent, foo);
   * console.log(parent.nodes.length); //=> 2
   * ```
   * @param {Object} `parent`
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Object|undefined} Returns the removed node, if successful, or undefined if it does not exist on `parent.nodes`.
   * @api public
   */
  
  utils.removeNode = function(parent, node) {
    assert(utils.isNode(parent), 'expected parent to be an instance of Node');
    if (!parent.nodes) return;
    if (!node) return;
  
    if (typeof parent.remove === 'function') {
      return parent.remove(node);
    }
  
    var idx = parent.nodes.indexOf(node);
    if (idx !== -1) {
      return parent.nodes.splice(idx, 1);
    }
  };
  
  /**
   * Returns true if `node.type` matches the given `type`. Throws a
   * `TypeError` if `node` is not an instance of `Node`.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var node = new Node({type: 'foo'});
   * console.log(utils.isType(node, 'foo')); // false
   * console.log(utils.isType(node, 'bar')); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {String} `type`
   * @return {Boolean}
   * @api public
   */
  
  utils.isType = function(node, type) {
    if (!utils.isNode(node)) return false;
    switch (typeOf(type)) {
      case 'string':
        return node.type === type;
      case 'regexp':
        return type.test(node.type);
      case 'array':
        for (const key of type.slice()) {
          if (utils.isType(node, key)) {
            return true;
          }
        }
        return false;
      default: {
        throw new TypeError('expected "type" to be an array, string or regexp');
      }
    }
  };
  
  /**
   * Returns true if the given `node` has the given `type` in `node.nodes`.
   * Throws a `TypeError` if `node` is not an instance of `Node`.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var node = new Node({
   *   type: 'foo',
   *   nodes: [
   *     new Node({type: 'bar'}),
   *     new Node({type: 'baz'})
   *   ]
   * });
   * console.log(utils.hasType(node, 'xyz')); // false
   * console.log(utils.hasType(node, 'baz')); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {String} `type`
   * @return {Boolean}
   * @api public
   */
  
  utils.hasType = function(node, type) {
    if (!utils.isNode(node)) return false;
    if (!Array.isArray(node.nodes)) return false;
    for (const child of node.nodes) {
      if (utils.isType(child, type)) {
        return true;
      }
    }
    return false;
  };
  
  /**
   * Returns the first node from `node.nodes` of the given `type`
   *
   * ```js
   * var node = new Node({
   *   type: 'foo',
   *   nodes: [
   *     new Node({type: 'text', value: 'abc'}),
   *     new Node({type: 'text', value: 'xyz'})
   *   ]
   * });
   *
   * var textNode = utils.firstOfType(node.nodes, 'text');
   * console.log(textNode.value);
   * //=> 'abc'
   * ```
   * @param {Array} `nodes`
   * @param {String} `type`
   * @return {Object|undefined} Returns the first matching node or undefined.
   * @api public
   */
  
  utils.firstOfType = function(nodes, type) {
    for (const node of nodes) {
      if (utils.isType(node, type)) {
        return node;
      }
    }
  };
  
  /**
   * Returns the node at the specified index, or the first node of the
   * given `type` from `node.nodes`.
   *
   * ```js
   * var node = new Node({
   *   type: 'foo',
   *   nodes: [
   *     new Node({type: 'text', value: 'abc'}),
   *     new Node({type: 'text', value: 'xyz'})
   *   ]
   * });
   *
   * var nodeOne = utils.findNode(node.nodes, 'text');
   * console.log(nodeOne.value);
   * //=> 'abc'
   *
   * var nodeTwo = utils.findNode(node.nodes, 1);
   * console.log(nodeTwo.value);
   * //=> 'xyz'
   * ```
   *
   * @param {Array} `nodes`
   * @param {String|Number} `type` Node type or index.
   * @return {Object} Returns a node or undefined.
   * @api public
   */
  
  utils.findNode = function(nodes, type) {
    if (!Array.isArray(nodes)) return null;
    if (typeof type === 'number') return nodes[type];
    return utils.firstOfType(nodes, type);
  };
  
  /**
   * Returns true if the given node is an "*.open" node.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var brace = new Node({type: 'brace'});
   * var open = new Node({type: 'brace.open'});
   * var close = new Node({type: 'brace.close'});
   *
   * console.log(utils.isOpen(brace)); // false
   * console.log(utils.isOpen(open)); // true
   * console.log(utils.isOpen(close)); // false
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Boolean}
   * @api public
   */
  
  utils.isOpen = function(node) {
    if (!node) return false;
    if (node.parent && typeof node.parent.isOpen === 'function') {
      return node.parent.isOpen(node);
    }
    if (node && typeof node.isOpen === 'function') {
      return node.isOpen(node);
    }
    return node.type ? node.type.slice(-5) === '.open' : false;
  };
  
  /**
   * Returns true if the given node is a "*.close" node.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var brace = new Node({type: 'brace'});
   * var open = new Node({type: 'brace.open'});
   * var close = new Node({type: 'brace.close'});
   *
   * console.log(utils.isClose(brace)); // false
   * console.log(utils.isClose(open)); // false
   * console.log(utils.isClose(close)); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Boolean}
   * @api public
   */
  
  utils.isClose = function(node) {
    if (!node) return false;
    if (node.parent && typeof node.parent.isClose === 'function') {
      return node.parent.isClose(node);
    }
    if (node && typeof node.isClose === 'function') {
      return node.isClose(node);
    }
    return node.type ? node.type.slice(-6) === '.close' : false;
  };
  
  /**
   * Returns true if the given node is an "*.open" node.
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var brace = new Node({type: 'brace'});
   * var open = new Node({type: 'brace.open', value: '{'});
   * var inner = new Node({type: 'text', value: 'a,b,c'});
   * var close = new Node({type: 'brace.close', value: '}'});
   * brace.push(open);
   * brace.push(inner);
   * brace.push(close);
   *
   * console.log(utils.isBlock(brace)); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Boolean}
   * @api public
   */
  
  utils.isBlock = function(node) {
    if (!node || !utils.isNode(node)) return false;
    if (!Array.isArray(node.nodes)) {
      return false;
    }
    if (node.parent && typeof node.parent.isBlock === 'function') {
      return node.parent.isBlock(node);
    }
    if (typeof node.isBlock === 'function') {
      return node.isBlock(node);
    }
    return utils.hasOpenAndClose(node);
  };
  
  /**
   * Returns true if `parent.nodes` has the given `node`.
   *
   * ```js
   * const foo = new Node({type: 'foo'});
   * const bar = new Node({type: 'bar'});
   * cosole.log(util.hasNode(foo, bar)); // false
   * foo.push(bar);
   * cosole.log(util.hasNode(foo, bar)); // true
   * ```
   * @param {String} `type`
   * @return {Boolean}
   * @api public
   */
  
  utils.hasNode = function(node, child) {
    if (!utils.isNode(node)) return false;
    if (typeof node.has === 'function') {
      return node.has(child);
    }
    if (node.nodes) {
      return node.nodes.indexOf(child) !== -1;
    }
    return false;
  };
  
  /**
   * Returns true if `node.nodes` **has** an `.open` node
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var brace = new Node({
   *   type: 'brace',
   *   nodes: []
   * });
   *
   * var open = new Node({type: 'brace.open'});
   * console.log(utils.hasOpen(brace)); // false
   *
   * brace.pushNode(open);
   * console.log(utils.hasOpen(brace)); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Boolean}
   * @api public
   */
  
  utils.hasOpen = function(node) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    var first = node.first || node.nodes ? node.nodes[0] : null;
    if (!utils.isNode(first)) return false;
    if (node.isOpen === 'function') {
      return node.isOpen(first);
    }
    return first.type === node.type + '.open';
  };
  
  /**
   * Returns true if `node.nodes` **has** a `.close` node
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var brace = new Node({
   *   type: 'brace',
   *   nodes: []
   * });
   *
   * var close = new Node({type: 'brace.close'});
   * console.log(utils.hasClose(brace)); // false
   *
   * brace.pushNode(close);
   * console.log(utils.hasClose(brace)); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Boolean}
   * @api public
   */
  
  utils.hasClose = function(node) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    var last = node.last || node.nodes ? node.nodes[node.nodes.length - 1] : null;
    if (!utils.isNode(last)) return false;
    if (typeof node.isClose === 'function') {
      return node.isClose(last);
    }
    return last.type === node.type + '.close';
  };
  
  /**
   * Returns true if `node.nodes` has both `.open` and `.close` nodes
   *
   * ```js
   * var Node = require('snapdragon-node');
   * var brace = new Node({
   *   type: 'brace',
   *   nodes: []
   * });
   *
   * var open = new Node({type: 'brace.open'});
   * var close = new Node({type: 'brace.close'});
   * console.log(utils.hasOpen(brace)); // false
   * console.log(utils.hasClose(brace)); // false
   *
   * brace.pushNode(open);
   * brace.pushNode(close);
   * console.log(utils.hasOpen(brace)); // true
   * console.log(utils.hasClose(brace)); // true
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Boolean}
   * @api public
   */
  
  utils.hasOpenAndClose = function(node) {
    return utils.hasOpen(node) && utils.hasClose(node);
  };
  
  /**
   * Push the given `node` onto the `state.inside` array for the
   * given type. This array is used as a specialized "stack" for
   * only the given `node.type`.
   *
   * ```js
   * var state = { inside: {}};
   * var node = new Node({type: 'brace'});
   * utils.addType(state, node);
   * console.log(state.inside);
   * //=> { brace: [{type: 'brace'}] }
   * ```
   * @param {Object} `state` The `compiler.state` object or custom state object.
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Array} Returns the `state.inside` stack for the given type.
   * @api public
   */
  
  utils.addType = function(state, node) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    assert(isObject(state), 'expected state to be an object');
  
    var type = node.parent
      ? node.parent.type
      : node.type.replace(/\.open$/, '');
  
    if (!state.hasOwnProperty('inside')) {
      state.inside = {};
    }
    if (!state.inside.hasOwnProperty(type)) {
      state.inside[type] = [];
    }
  
    var arr = state.inside[type];
    arr.push(node);
    return arr;
  };
  
  /**
   * Remove the given `node` from the `state.inside` array for the
   * given type. This array is used as a specialized "stack" for
   * only the given `node.type`.
   *
   * ```js
   * var state = { inside: {}};
   * var node = new Node({type: 'brace'});
   * utils.addType(state, node);
   * console.log(state.inside);
   * //=> { brace: [{type: 'brace'}] }
   * utils.removeType(state, node);
   * //=> { brace: [] }
   * ```
   * @param {Object} `state` The `compiler.state` object or custom state object.
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @return {Array} Returns the `state.inside` stack for the given type.
   * @api public
   */
  
  utils.removeType = function(state, node) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    assert(isObject(state), 'expected state to be an object');
  
    var type = node.parent
      ? node.parent.type
      : node.type.replace(/\.close$/, '');
  
    if (state.inside.hasOwnProperty(type)) {
      return state.inside[type].pop();
    }
  };
  
  /**
   * Returns true if `node.value` is an empty string, or `node.nodes` does
   * not contain any non-empty text nodes.
   *
   * ```js
   * var node = new Node({type: 'text'});
   * utils.isEmpty(node); //=> true
   * node.value = 'foo';
   * utils.isEmpty(node); //=> false
   * ```
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {Function} `fn`
   * @return {Boolean}
   * @api public
   */
  
  utils.isEmpty = function(node, fn) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
  
    if (!Array.isArray(node.nodes)) {
      if (typeof fn === 'function') {
        return fn(node);
      }
      return !utils.value(node);
    }
  
    if (node.nodes.length === 0) {
      return true;
    }
  
    for (const child of node.nodes) {
      if (!utils.isEmpty(child, fn)) {
        return false;
      }
    }
  
    return true;
  };
  
  /**
   * Returns true if the `state.inside` stack for the given type exists
   * and has one or more nodes on it.
   *
   * ```js
   * var state = { inside: {}};
   * var node = new Node({type: 'brace'});
   * console.log(utils.isInsideType(state, 'brace')); //=> false
   * utils.addType(state, node);
   * console.log(utils.isInsideType(state, 'brace')); //=> true
   * utils.removeType(state, node);
   * console.log(utils.isInsideType(state, 'brace')); //=> false
   * ```
   * @param {Object} `state`
   * @param {String} `type`
   * @return {Boolean}
   * @api public
   */
  
  utils.isInsideType = function(state, type) {
    assert(isObject(state), 'expected state to be an object');
    assert(isString(type), 'expected type to be a string');
  
    if (!state.hasOwnProperty('inside')) {
      return false;
    }
  
    if (!state.inside.hasOwnProperty(type)) {
      return false;
    }
  
    return state.inside[type].length > 0;
  };
  
  /**
   * Returns true if `node` is either a child or grand-child of the given `type`,
   * or `state.inside[type]` is a non-empty array.
   *
   * ```js
   * var state = { inside: {}};
   * var node = new Node({type: 'brace'});
   * var open = new Node({type: 'brace.open'});
   * console.log(utils.isInside(state, open, 'brace')); //=> false
   * utils.pushNode(node, open);
   * console.log(utils.isInside(state, open, 'brace')); //=> true
   * ```
   * @param {Object} `state` Either the `compiler.state` object, if it exists, or a user-supplied state object.
   * @param {Object} `node` Instance of [snapdragon-node][]
   * @param {String} `type` The `node.type` to check for.
   * @return {Boolean}
   * @api public
   */
  
  utils.isInside = function(state, node, type) {
    assert(utils.isNode(node), 'expected node to be an instance of Node');
    assert(isObject(state), 'expected state to be an object');
  
    if (Array.isArray(type)) {
      for (var i = 0; i < type.length; i++) {
        if (utils.isInside(state, node, type[i])) {
          return true;
        }
      }
      return false;
    }
  
    var parent = node.parent;
    if (typeof type === 'string') {
      return (parent && parent.type === type) || utils.isInsideType(state, type);
    }
  
    if (typeOf(type) === 'regexp') {
      if (parent && parent.type && type.test(parent.type)) {
        return true;
      }
  
      var keys = Object.keys(state.inside);
      var len = keys.length;
      var idx = -1;
      while (++idx < len) {
        var key = keys[idx];
        var value = state.inside[key];
  
        if (Array.isArray(value) && value.length !== 0 && type.test(key)) {
          return true;
        }
      }
    }
    return false;
  };
  
  /**
   * Get the last `n` element from the given `array`. Used for getting
   * a node from `node.nodes.`
   *
   * @param {Array} `array`
   * @param {Number} `n`
   * @return {undefined}
   * @api public
   */
  
  utils.last = function(arr, n) {
    return Array.isArray(arr) ? arr[arr.length - (n || 1)] : null;
  };
  
  utils.lastNode = function(node) {
    return Array.isArray(node.nodes) ? utils.last(node.nodes) : null;
  };
  
  /**
   * Cast the given `value` to an array.
   *
   * ```js
   * console.log(utils.arrayify(''));
   * //=> []
   * console.log(utils.arrayify('foo'));
   * //=> ['foo']
   * console.log(utils.arrayify(['foo']));
   * //=> ['foo']
   * ```
   * @param {any} `value`
   * @return {Array}
   * @api public
   */
  
  utils.arrayify = function(value) {
    if (typeof value === 'string' && value !== '') {
      return [value];
    }
    if (!Array.isArray(value)) {
      return [];
    }
    return value;
  };
  
  /**
   * Convert the given `value` to a string by joining with `,`. Useful
   * for creating a cheerio/CSS/DOM-style selector from a list of strings.
   *
   * @param {any} `value`
   * @return {Array}
   * @api public
   */
  
  utils.stringify = function(value) {
    return utils.arrayify(value).join(',');
  };
  
  /**
   * Ensure that the given value is a string and call `.trim()` on it,
   * or return an empty string.
   *
   * @param {String} `str`
   * @return {String}
   * @api public
   */
  
  utils.trim = function(str) {
    return typeof str === 'string' ? str.trim() : '';
  };
  
  /**
   * Return true if value is an object
   */
  
  function isObject(value) {
    return typeOf(value) === 'object';
  }
  
  /**
   * Return true if value is a string
   */
  
  function isString(value) {
    return typeof value === 'string';
  }
  
  /**
   * Return true if value is a function
   */
  
  function isFunction(value) {
    return typeof value === 'function';
  }
  
  /**
   * Return true if value is an array
   */
  
  function isArray(value) {
    return Array.isArray(value);
  }
  
  /**
   * Shim to ensure the `.append` methods work with any version of snapdragon
   */
  
  function append(compiler, value, node) {
    if (typeof compiler.append !== 'function') {
      return compiler.emit(value, node);
    }
    return compiler.append(value, node);
  }
  
  /**
   * Simplified assertion. Throws an error is `value` is falsey.
   */
  
  function assert(value, message) {
    if (!value) throw new Error(message);
  }
  function expect(node, name, Node) {
    const isNode = (Node && Node.isNode) ? Node.isNode : utils.isNode;
    assert(isNode(node), `expected ${name} to be an instance of Node`);
  }
  