--- /dev/null
+'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);
+};
+
+/**
+ * Appdend `node.val` to `compiler.output`, exactly as it was created
+ * by the parser.
+ *
+ * ```js
+ * snapdragon.compiler.set('text', utils.identity);
+ * ```
+ * @param {Object} `node` Instance of [snapdragon-node][]
+ * @returns {undefined}
+ * @api public
+ */
+
+utils.identity = function(node) {
+ append(this, node.val, node);
+};
+
+/**
+ * Previously named `.emit`, this method appends the given `val`
+ * to `compiler.output` for the given node. Useful when you know
+ * what value should be appended advance, regardless of the actual
+ * value of `node.val`.
+ *
+ * ```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(val) {
+ return function(node) {
+ append(this, val, 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.val = '';
+ }
+};
+
+/**
+ * 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(utils.isNode(node), 'expected node to be an instance of Node');
+ assert(isFunction(fn), 'expected a visitor function');
+ 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(utils.isNode(node), 'expected node to be an instance of Node');
+ assert(isArray(node.nodes), 'expected node.nodes to be an array');
+ assert(isFunction(fn), 'expected a visitor function');
+
+ 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', val: '' };
+ *
+ * // 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, val, filter) {
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+ assert(isFunction(Node), 'expected Node to be a constructor function');
+
+ if (typeof val === 'function') {
+ filter = val;
+ val = '';
+ }
+
+ if (typeof filter === 'function' && !filter(node)) return;
+ var open = new Node({ type: node.type + '.open', val: val});
+ 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', val: '' };
+ *
+ * // 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, val, filter) {
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+ assert(isFunction(Node), 'expected Node to be a constructor function');
+
+ if (typeof val === 'function') {
+ filter = val;
+ val = '';
+ }
+
+ if (typeof filter === 'function' && !filter(node)) return;
+ var close = new Node({ type: node.type + '.close', val: val});
+ 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');
+ assert(utils.isNode(node), 'expected node to be an instance of 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');
+ assert(utils.isNode(node), 'expected node to be an instance of 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.node to be an instance of Node');
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+
+ if (!parent.nodes) {
+ return null;
+ }
+
+ 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) {
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+ switch (typeOf(type)) {
+ case 'array':
+ var types = type.slice();
+ for (var i = 0; i < types.length; i++) {
+ if (utils.isType(node, types[i])) {
+ return true;
+ }
+ }
+ return false;
+ case 'string':
+ return node.type === type;
+ case 'regexp':
+ return type.test(node.type);
+ 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) {
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+ if (!Array.isArray(node.nodes)) return false;
+ for (var i = 0; i < node.nodes.length; i++) {
+ if (utils.isType(node.nodes[i], 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', val: 'abc'}),
+ * new Node({type: 'text', val: 'xyz'})
+ * ]
+ * });
+ *
+ * var textNode = utils.firstOfType(node.nodes, 'text');
+ * console.log(textNode.val);
+ * //=> '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 (var i = 0; i < nodes.length; i++) {
+ var node = nodes[i];
+ 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', val: 'abc'}),
+ * new Node({type: 'text', val: 'xyz'})
+ * ]
+ * });
+ *
+ * var nodeOne = utils.findNode(node.nodes, 'text');
+ * console.log(nodeOne.val);
+ * //=> 'abc'
+ *
+ * var nodeTwo = utils.findNode(node.nodes, 1);
+ * console.log(nodeTwo.val);
+ * //=> '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) {
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+ return node.type.slice(-5) === '.open';
+};
+
+/**
+ * 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) {
+ assert(utils.isNode(node), 'expected node to be an instance of Node');
+ return node.type.slice(-6) === '.close';
+};
+
+/**
+ * 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 first.type === node.type + '.open';
+ }
+ return false;
+};
+
+/**
+ * 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 last.type === node.type + '.close';
+ }
+ return false;
+};
+
+/**
+ * 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.val` 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.val = '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 (node.type !== 'text') {
+ return true;
+ }
+ if (typeof fn === 'function') {
+ return fn(node, node.parent);
+ }
+ return !utils.trim(node.val);
+ }
+
+ for (var i = 0; i < node.nodes.length; i++) {
+ var child = node.nodes[i];
+ if (utils.isOpen(child) || utils.isClose(child)) {
+ continue;
+ }
+ 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 val = state.inside[key];
+
+ if (Array.isArray(val) && val.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 arr[arr.length - (n || 1)];
+};
+
+/**
+ * Cast the given `val` to an array.
+ *
+ * ```js
+ * console.log(utils.arrayify(''));
+ * //=> []
+ * console.log(utils.arrayify('foo'));
+ * //=> ['foo']
+ * console.log(utils.arrayify(['foo']));
+ * //=> ['foo']
+ * ```
+ * @param {any} `val`
+ * @return {Array}
+ * @api public
+ */
+
+utils.arrayify = function(val) {
+ if (typeof val === 'string' && val !== '') {
+ return [val];
+ }
+ if (!Array.isArray(val)) {
+ return [];
+ }
+ return val;
+};
+
+/**
+ * Convert the given `val` to a string by joining with `,`. Useful
+ * for creating a cheerio/CSS/DOM-style selector from a list of strings.
+ *
+ * @param {any} `val`
+ * @return {Array}
+ * @api public
+ */
+
+utils.stringify = function(val) {
+ return utils.arrayify(val).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 val is an object
+ */
+
+function isObject(val) {
+ return typeOf(val) === 'object';
+}
+
+/**
+ * Return true if val is a string
+ */
+
+function isString(val) {
+ return typeof val === 'string';
+}
+
+/**
+ * Return true if val is a function
+ */
+
+function isFunction(val) {
+ return typeof val === 'function';
+}
+
+/**
+ * Return true if val is an array
+ */
+
+function isArray(val) {
+ return Array.isArray(val);
+}
+
+/**
+ * Shim to ensure the `.append` methods work with any version of snapdragon
+ */
+
+function append(compiler, val, node) {
+ if (typeof compiler.append !== 'function') {
+ return compiler.emit(val, node);
+ }
+ return compiler.append(val, node);
+}
+
+/**
+ * Simplified assertion. Throws an error is `val` is falsey.
+ */
+
+function assert(val, message) {
+ if (!val) throw new Error(message);
+}
projects / dotfiles / .git / blobdiff