| Server IP : 199.250.214.225 / Your IP : 3.144.248.117 Web Server : Apache System : Linux vps64074.inmotionhosting.com 3.10.0-1160.105.1.vz7.214.3 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : nicngo5 ( 1001) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /home/nicngo5/cms/node_modules/snapdragon-node/ |
Upload File : |
'use strict';
var isObject = require('isobject');
var define = require('define-property');
var utils = require('snapdragon-util');
var ownNames;
/**
* Create a new AST `Node` with the given `val` and `type`.
*
* ```js
* var node = new Node('*', 'Star');
* var node = new Node({type: 'star', val: '*'});
* ```
* @name Node
* @param {String|Object} `val` Pass a matched substring, or an object to merge onto the node.
* @param {String} `type` The node type to use when `val` is a string.
* @return {Object} node instance
* @api public
*/
function Node(val, type, parent) {
if (typeof type !== 'string') {
parent = type;
type = null;
}
define(this, 'parent', parent);
define(this, 'isNode', true);
define(this, 'expect', null);
if (typeof type !== 'string' && isObject(val)) {
lazyKeys();
var keys = Object.keys(val);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (ownNames.indexOf(key) === -1) {
this[key] = val[key];
}
}
} else {
this.type = type;
this.val = val;
}
}
/**
* Returns true if the given value is a node.
*
* ```js
* var Node = require('snapdragon-node');
* var node = new Node({type: 'foo'});
* console.log(Node.isNode(node)); //=> true
* console.log(Node.isNode({})); //=> false
* ```
* @param {Object} `node`
* @returns {Boolean}
* @api public
*/
Node.isNode = function(node) {
return utils.isNode(node);
};
/**
* Define a non-enumberable property on the node instance.
* Useful for adding properties that shouldn't be extended
* or visible during debugging.
*
* ```js
* var node = new Node();
* node.define('foo', 'something non-enumerable');
* ```
* @param {String} `name`
* @param {any} `val`
* @return {Object} returns the node instance
* @api public
*/
Node.prototype.define = function(name, val) {
define(this, name, val);
return this;
};
/**
* 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'});
* node.isEmpty(); //=> true
* node.val = 'foo';
* node.isEmpty(); //=> false
* ```
* @param {Function} `fn` (optional) Filter function that is called on `node` and/or child nodes. `isEmpty` will return false immediately when the filter function returns false on any nodes.
* @return {Boolean}
* @api public
*/
Node.prototype.isEmpty = function(fn) {
return utils.isEmpty(this, fn);
};
/**
* Given node `foo` and node `bar`, push node `bar` onto `foo.nodes`, and
* set `foo` as `bar.parent`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* foo.push(bar);
* ```
* @param {Object} `node`
* @return {Number} Returns the length of `node.nodes`
* @api public
*/
Node.prototype.push = function(node) {
assert(Node.isNode(node), 'expected node to be an instance of Node');
define(node, 'parent', this);
this.nodes = this.nodes || [];
return this.nodes.push(node);
};
/**
* Given node `foo` and node `bar`, unshift node `bar` onto `foo.nodes`, and
* set `foo` as `bar.parent`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* foo.unshift(bar);
* ```
* @param {Object} `node`
* @return {Number} Returns the length of `node.nodes`
* @api public
*/
Node.prototype.unshift = function(node) {
assert(Node.isNode(node), 'expected node to be an instance of Node');
define(node, 'parent', this);
this.nodes = this.nodes || [];
return this.nodes.unshift(node);
};
/**
* Pop a node from `node.nodes`.
*
* ```js
* var node = new Node({type: 'foo'});
* node.push(new Node({type: 'a'}));
* node.push(new Node({type: 'b'}));
* node.push(new Node({type: 'c'}));
* node.push(new Node({type: 'd'}));
* console.log(node.nodes.length);
* //=> 4
* node.pop();
* console.log(node.nodes.length);
* //=> 3
* ```
* @return {Number} Returns the popped `node`
* @api public
*/
Node.prototype.pop = function() {
return this.nodes && this.nodes.pop();
};
/**
* Shift a node from `node.nodes`.
*
* ```js
* var node = new Node({type: 'foo'});
* node.push(new Node({type: 'a'}));
* node.push(new Node({type: 'b'}));
* node.push(new Node({type: 'c'}));
* node.push(new Node({type: 'd'}));
* console.log(node.nodes.length);
* //=> 4
* node.shift();
* console.log(node.nodes.length);
* //=> 3
* ```
* @return {Object} Returns the shifted `node`
* @api public
*/
Node.prototype.shift = function() {
return this.nodes && this.nodes.shift();
};
/**
* Remove `node` from `node.nodes`.
*
* ```js
* node.remove(childNode);
* ```
* @param {Object} `node`
* @return {Object} Returns the removed node.
* @api public
*/
Node.prototype.remove = function(node) {
assert(Node.isNode(node), 'expected node to be an instance of Node');
this.nodes = this.nodes || [];
var idx = node.index;
if (idx !== -1) {
node.index = -1;
return this.nodes.splice(idx, 1);
}
return null;
};
/**
* Get the first child node from `node.nodes` that matches the given `type`.
* If `type` is a number, the child node at that index is returned.
*
* ```js
* var child = node.find(1); //<= index of the node to get
* var child = node.find('foo'); //<= node.type of a child node
* var child = node.find(/^(foo|bar)$/); //<= regex to match node.type
* var child = node.find(['foo', 'bar']); //<= array of node.type(s)
* ```
* @param {String} `type`
* @return {Object} Returns a child node or undefined.
* @api public
*/
Node.prototype.find = function(type) {
return utils.findNode(this.nodes, type);
};
/**
* Return true if the node is the given `type`.
*
* ```js
* var node = new Node({type: 'bar'});
* cosole.log(node.isType('foo')); // false
* cosole.log(node.isType(/^(foo|bar)$/)); // true
* cosole.log(node.isType(['foo', 'bar'])); // true
* ```
* @param {String} `type`
* @return {Boolean}
* @api public
*/
Node.prototype.isType = function(type) {
return utils.isType(this, type);
};
/**
* Return true if the `node.nodes` has the given `type`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* foo.push(bar);
*
* cosole.log(foo.hasType('qux')); // false
* cosole.log(foo.hasType(/^(qux|bar)$/)); // true
* cosole.log(foo.hasType(['qux', 'bar'])); // true
* ```
* @param {String} `type`
* @return {Boolean}
* @api public
*/
Node.prototype.hasType = function(type) {
return utils.hasType(this, type);
};
/**
* Get the siblings array, or `null` if it doesn't exist.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* foo.push(bar);
* foo.push(baz);
*
* console.log(bar.siblings.length) // 2
* console.log(baz.siblings.length) // 2
* ```
* @return {Array}
* @api public
*/
Object.defineProperty(Node.prototype, 'siblings', {
set: function() {
throw new Error('node.siblings is a getter and cannot be defined');
},
get: function() {
return this.parent ? this.parent.nodes : null;
}
});
/**
* Get the node's current index from `node.parent.nodes`.
* This should always be correct, even when the parent adds nodes.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* var qux = new Node({type: 'qux'});
* foo.push(bar);
* foo.push(baz);
* foo.unshift(qux);
*
* console.log(bar.index) // 1
* console.log(baz.index) // 2
* console.log(qux.index) // 0
* ```
* @return {Number}
* @api public
*/
Object.defineProperty(Node.prototype, 'index', {
set: function(index) {
define(this, 'idx', index);
},
get: function() {
if (!Array.isArray(this.siblings)) {
return -1;
}
var tok = this.idx !== -1 ? this.siblings[this.idx] : null;
if (tok !== this) {
this.idx = this.siblings.indexOf(this);
}
return this.idx;
}
});
/**
* Get the previous node from the siblings array or `null`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* foo.push(bar);
* foo.push(baz);
*
* console.log(baz.prev.type) // 'bar'
* ```
* @return {Object}
* @api public
*/
Object.defineProperty(Node.prototype, 'prev', {
set: function() {
throw new Error('node.prev is a getter and cannot be defined');
},
get: function() {
if (Array.isArray(this.siblings)) {
return this.siblings[this.index - 1] || this.parent.prev;
}
return null;
}
});
/**
* Get the siblings array, or `null` if it doesn't exist.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* foo.push(bar);
* foo.push(baz);
*
* console.log(bar.siblings.length) // 2
* console.log(baz.siblings.length) // 2
* ```
* @return {Object}
* @api public
*/
Object.defineProperty(Node.prototype, 'next', {
set: function() {
throw new Error('node.next is a getter and cannot be defined');
},
get: function() {
if (Array.isArray(this.siblings)) {
return this.siblings[this.index + 1] || this.parent.next;
}
return null;
}
});
/**
* Get the first node from `node.nodes`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* var qux = new Node({type: 'qux'});
* foo.push(bar);
* foo.push(baz);
* foo.push(qux);
*
* console.log(foo.first.type) // 'bar'
* ```
* @return {Object} The first node, or undefiend
* @api public
*/
Object.defineProperty(Node.prototype, 'first', {
get: function() {
return this.nodes ? this.nodes[0] : null;
}
});
/**
* Get the last node from `node.nodes`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* var qux = new Node({type: 'qux'});
* foo.push(bar);
* foo.push(baz);
* foo.push(qux);
*
* console.log(foo.last.type) // 'qux'
* ```
* @return {Object} The last node, or undefiend
* @api public
*/
Object.defineProperty(Node.prototype, 'last', {
get: function() {
return this.nodes ? utils.last(this.nodes) : null;
}
});
/**
* Get the last node from `node.nodes`.
*
* ```js
* var foo = new Node({type: 'foo'});
* var bar = new Node({type: 'bar'});
* var baz = new Node({type: 'baz'});
* var qux = new Node({type: 'qux'});
* foo.push(bar);
* foo.push(baz);
* foo.push(qux);
*
* console.log(foo.last.type) // 'qux'
* ```
* @return {Object} The last node, or undefiend
* @api public
*/
Object.defineProperty(Node.prototype, 'scope', {
get: function() {
if (this.isScope !== true) {
return this.parent ? this.parent.scope : this;
}
return this;
}
});
/**
* Get own property names from Node prototype, but only the
* first time `Node` is instantiated
*/
function lazyKeys() {
if (!ownNames) {
ownNames = Object.getOwnPropertyNames(Node.prototype);
}
}
/**
* Simplified assertion. Throws an error is `val` is falsey.
*/
function assert(val, message) {
if (!val) throw new Error(message);
}
/**
* Expose `Node`
*/
exports = module.exports = Node;