| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/jungly/node_modules/snapdragon/lib/ |
Upload File : |
'use strict';
var use = require('use');
var util = require('util');
var Cache = require('map-cache');
var define = require('define-property');
var debug = require('debug')('snapdragon:parser');
var Position = require('./position');
var utils = require('./utils');
/**
* Create a new `Parser` with the given `input` and `options`.
* @param {String} `input`
* @param {Object} `options`
* @api public
*/
function Parser(options) {
debug('initializing', __filename);
this.options = utils.extend({source: 'string'}, options);
this.init(this.options);
use(this);
}
/**
* Prototype methods
*/
Parser.prototype = {
constructor: Parser,
init: function(options) {
this.orig = '';
this.input = '';
this.parsed = '';
this.column = 1;
this.line = 1;
this.regex = new Cache();
this.errors = this.errors || [];
this.parsers = this.parsers || {};
this.types = this.types || [];
this.sets = this.sets || {};
this.fns = this.fns || [];
this.currentType = 'root';
var pos = this.position();
this.bos = pos({type: 'bos', val: ''});
this.ast = {
type: 'root',
errors: this.errors,
nodes: [this.bos]
};
define(this.bos, 'parent', this.ast);
this.nodes = [this.ast];
this.count = 0;
this.setCount = 0;
this.stack = [];
},
/**
* Throw a formatted error with the cursor column and `msg`.
* @param {String} `msg` Message to use in the Error.
*/
error: function(msg, node) {
var pos = node.position || {start: {column: 0, line: 0}};
var line = pos.start.line;
var column = pos.start.column;
var source = this.options.source;
var message = source + ' <line:' + line + ' column:' + column + '>: ' + msg;
var err = new Error(message);
err.source = source;
err.reason = msg;
err.pos = pos;
if (this.options.silent) {
this.errors.push(err);
} else {
throw err;
}
},
/**
* Define a non-enumberable property on the `Parser` instance.
*
* ```js
* parser.define('foo', 'bar');
* ```
* @name .define
* @param {String} `key` propery name
* @param {any} `val` property value
* @return {Object} Returns the Parser instance for chaining.
* @api public
*/
define: function(key, val) {
define(this, key, val);
return this;
},
/**
* Mark position and patch `node.position`.
*/
position: function() {
var start = { line: this.line, column: this.column };
var self = this;
return function(node) {
define(node, 'position', new Position(start, self));
return node;
};
},
/**
* Set parser `name` with the given `fn`
* @param {String} `name`
* @param {Function} `fn`
* @api public
*/
set: function(type, fn) {
if (this.types.indexOf(type) === -1) {
this.types.push(type);
}
this.parsers[type] = fn.bind(this);
return this;
},
/**
* Get parser `name`
* @param {String} `name`
* @api public
*/
get: function(name) {
return this.parsers[name];
},
/**
* Push a `token` onto the `type` stack.
*
* @param {String} `type`
* @return {Object} `token`
* @api public
*/
push: function(type, token) {
this.sets[type] = this.sets[type] || [];
this.count++;
this.stack.push(token);
return this.sets[type].push(token);
},
/**
* Pop a token off of the `type` stack
* @param {String} `type`
* @returns {Object} Returns a token
* @api public
*/
pop: function(type) {
this.sets[type] = this.sets[type] || [];
this.count--;
this.stack.pop();
return this.sets[type].pop();
},
/**
* Return true if inside a `stack` node. Types are `braces`, `parens` or `brackets`.
*
* @param {String} `type`
* @return {Boolean}
* @api public
*/
isInside: function(type) {
this.sets[type] = this.sets[type] || [];
return this.sets[type].length > 0;
},
/**
* Return true if `node` is the given `type`.
*
* ```js
* parser.isType(node, 'brace');
* ```
* @param {Object} `node`
* @param {String} `type`
* @return {Boolean}
* @api public
*/
isType: function(node, type) {
return node && node.type === type;
},
/**
* Get the previous AST node
* @return {Object}
*/
prev: function(n) {
return this.stack.length > 0
? utils.last(this.stack, n)
: utils.last(this.nodes, n);
},
/**
* Update line and column based on `str`.
*/
consume: function(len) {
this.input = this.input.substr(len);
},
/**
* Update column based on `str`.
*/
updatePosition: function(str, len) {
var lines = str.match(/\n/g);
if (lines) this.line += lines.length;
var i = str.lastIndexOf('\n');
this.column = ~i ? len - i : this.column + len;
this.parsed += str;
this.consume(len);
},
/**
* Match `regex`, return captures, and update the cursor position by `match[0]` length.
* @param {RegExp} `regex`
* @return {Object}
*/
match: function(regex) {
var m = regex.exec(this.input);
if (m) {
this.updatePosition(m[0], m[0].length);
return m;
}
},
/**
* Capture `type` with the given regex.
* @param {String} `type`
* @param {RegExp} `regex`
* @return {Function}
*/
capture: function(type, regex) {
if (typeof regex === 'function') {
return this.set.apply(this, arguments);
}
this.regex.set(type, regex);
this.set(type, function() {
var parsed = this.parsed;
var pos = this.position();
var m = this.match(regex);
if (!m || !m[0]) return;
var prev = this.prev();
var node = pos({
type: type,
val: m[0],
parsed: parsed,
rest: this.input
});
if (m[1]) {
node.inner = m[1];
}
define(node, 'inside', this.stack.length > 0);
define(node, 'parent', prev);
prev.nodes.push(node);
}.bind(this));
return this;
},
/**
* Create a parser with open and close for parens,
* brackets or braces
*/
capturePair: function(type, openRegex, closeRegex, fn) {
this.sets[type] = this.sets[type] || [];
/**
* Open
*/
this.set(type + '.open', function() {
var parsed = this.parsed;
var pos = this.position();
var m = this.match(openRegex);
if (!m || !m[0]) return;
var val = m[0];
this.setCount++;
this.specialChars = true;
var open = pos({
type: type + '.open',
val: val,
rest: this.input
});
if (typeof m[1] !== 'undefined') {
open.inner = m[1];
}
var prev = this.prev();
var node = pos({
type: type,
nodes: [open]
});
define(node, 'rest', this.input);
define(node, 'parsed', parsed);
define(node, 'prefix', m[1]);
define(node, 'parent', prev);
define(open, 'parent', node);
if (typeof fn === 'function') {
fn.call(this, open, node);
}
this.push(type, node);
prev.nodes.push(node);
});
/**
* Close
*/
this.set(type + '.close', function() {
var pos = this.position();
var m = this.match(closeRegex);
if (!m || !m[0]) return;
var parent = this.pop(type);
var node = pos({
type: type + '.close',
rest: this.input,
suffix: m[1],
val: m[0]
});
if (!this.isType(parent, type)) {
if (this.options.strict) {
throw new Error('missing opening "' + type + '"');
}
this.setCount--;
node.escaped = true;
return node;
}
if (node.suffix === '\\') {
parent.escaped = true;
node.escaped = true;
}
parent.nodes.push(node);
define(node, 'parent', parent);
});
return this;
},
/**
* Capture end-of-string
*/
eos: function() {
var pos = this.position();
if (this.input) return;
var prev = this.prev();
while (prev.type !== 'root' && !prev.visited) {
if (this.options.strict === true) {
throw new SyntaxError('invalid syntax:' + util.inspect(prev, null, 2));
}
if (!hasDelims(prev)) {
prev.parent.escaped = true;
prev.escaped = true;
}
visit(prev, function(node) {
if (!hasDelims(node.parent)) {
node.parent.escaped = true;
node.escaped = true;
}
});
prev = prev.parent;
}
var tok = pos({
type: 'eos',
val: this.append || ''
});
define(tok, 'parent', this.ast);
return tok;
},
/**
* Run parsers to advance the cursor position
*/
next: function() {
var parsed = this.parsed;
var len = this.types.length;
var idx = -1;
var tok;
while (++idx < len) {
if ((tok = this.parsers[this.types[idx]].call(this))) {
define(tok, 'rest', this.input);
define(tok, 'parsed', parsed);
this.last = tok;
return tok;
}
}
},
/**
* Parse the given string.
* @return {Array}
*/
parse: function(input) {
if (typeof input !== 'string') {
throw new TypeError('expected a string');
}
this.init(this.options);
this.orig = input;
this.input = input;
var self = this;
function parse() {
// check input before calling `.next()`
input = self.input;
// get the next AST ndoe
var node = self.next();
if (node) {
var prev = self.prev();
if (prev) {
define(node, 'parent', prev);
if (prev.nodes) {
prev.nodes.push(node);
}
}
if (self.sets.hasOwnProperty(prev.type)) {
self.currentType = prev.type;
}
}
// if we got here but input is not changed, throw an error
if (self.input && input === self.input) {
throw new Error('no parsers registered for: "' + self.input.slice(0, 5) + '"');
}
}
while (this.input) parse();
if (this.stack.length && this.options.strict) {
var node = this.stack.pop();
throw this.error('missing opening ' + node.type + ': "' + this.orig + '"');
}
var eos = this.eos();
var tok = this.prev();
if (tok.type !== 'eos') {
this.ast.nodes.push(eos);
}
return this.ast;
}
};
/**
* Visit `node` with the given `fn`
*/
function visit(node, fn) {
if (!node.visited) {
define(node, 'visited', true);
return node.nodes ? mapVisit(node.nodes, fn) : fn(node);
}
return node;
}
/**
* Map visit over array of `nodes`.
*/
function mapVisit(nodes, fn) {
var len = nodes.length;
var idx = -1;
while (++idx < len) {
visit(nodes[idx], fn);
}
}
function hasOpen(node) {
return node.nodes && node.nodes[0].type === (node.type + '.open');
}
function hasClose(node) {
return node.nodes && utils.last(node.nodes).type === (node.type + '.close');
}
function hasDelims(node) {
return hasOpen(node) && hasClose(node);
}
/**
* Expose `Parser`
*/
module.exports = Parser;