Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/snapdragon/lib/compiler.js b/node_modules/snapdragon/lib/compiler.js
new file mode 100644
index 0000000..0ce9d21
--- /dev/null
+++ b/node_modules/snapdragon/lib/compiler.js
@@ -0,0 +1,177 @@
+'use strict';
+
+var use = require('use');
+var define = require('define-property');
+var debug = require('debug')('snapdragon:compiler');
+var utils = require('./utils');
+
+/**
+ * Create a new `Compiler` with the given `options`.
+ * @param {Object} `options`
+ */
+
+function Compiler(options, state) {
+ debug('initializing', __filename);
+ this.options = utils.extend({source: 'string'}, options);
+ this.state = state || {};
+ this.compilers = {};
+ this.output = '';
+ this.set('eos', function(node) {
+ return this.emit(node.val, node);
+ });
+ this.set('noop', function(node) {
+ return this.emit(node.val, node);
+ });
+ this.set('bos', function(node) {
+ return this.emit(node.val, node);
+ });
+ use(this);
+}
+
+/**
+ * Prototype methods
+ */
+
+Compiler.prototype = {
+
+ /**
+ * Throw an error message with details including the cursor position.
+ * @param {String} `msg` Message to use in the Error.
+ */
+
+ error: function(msg, node) {
+ var pos = node.position || {start: {column: 0}};
+ var message = this.options.source + ' column:' + pos.start.column + ': ' + msg;
+
+ var err = new Error(message);
+ err.reason = msg;
+ err.column = pos.start.column;
+ err.source = this.pattern;
+
+ if (this.options.silent) {
+ this.errors.push(err);
+ } else {
+ throw err;
+ }
+ },
+
+ /**
+ * Define a non-enumberable property on the `Compiler` instance.
+ *
+ * ```js
+ * compiler.define('foo', 'bar');
+ * ```
+ * @name .define
+ * @param {String} `key` propery name
+ * @param {any} `val` property value
+ * @return {Object} Returns the Compiler instance for chaining.
+ * @api public
+ */
+
+ define: function(key, val) {
+ define(this, key, val);
+ return this;
+ },
+
+ /**
+ * Emit `node.val`
+ */
+
+ emit: function(str, node) {
+ this.output += str;
+ return str;
+ },
+
+ /**
+ * Add a compiler `fn` with the given `name`
+ */
+
+ set: function(name, fn) {
+ this.compilers[name] = fn;
+ return this;
+ },
+
+ /**
+ * Get compiler `name`.
+ */
+
+ get: function(name) {
+ return this.compilers[name];
+ },
+
+ /**
+ * Get the previous AST node.
+ */
+
+ prev: function(n) {
+ return this.ast.nodes[this.idx - (n || 1)] || { type: 'bos', val: '' };
+ },
+
+ /**
+ * Get the next AST node.
+ */
+
+ next: function(n) {
+ return this.ast.nodes[this.idx + (n || 1)] || { type: 'eos', val: '' };
+ },
+
+ /**
+ * Visit `node`.
+ */
+
+ visit: function(node, nodes, i) {
+ var fn = this.compilers[node.type];
+ this.idx = i;
+
+ if (typeof fn !== 'function') {
+ throw this.error('compiler "' + node.type + '" is not registered', node);
+ }
+ return fn.call(this, node, nodes, i);
+ },
+
+ /**
+ * Map visit over array of `nodes`.
+ */
+
+ mapVisit: function(nodes) {
+ if (!Array.isArray(nodes)) {
+ throw new TypeError('expected an array');
+ }
+ var len = nodes.length;
+ var idx = -1;
+ while (++idx < len) {
+ this.visit(nodes[idx], nodes, idx);
+ }
+ return this;
+ },
+
+ /**
+ * Compile `ast`.
+ */
+
+ compile: function(ast, options) {
+ var opts = utils.extend({}, this.options, options);
+ this.ast = ast;
+ this.parsingErrors = this.ast.errors;
+ this.output = '';
+
+ // source map support
+ if (opts.sourcemap) {
+ var sourcemaps = require('./source-maps');
+ sourcemaps(this);
+ this.mapVisit(this.ast.nodes);
+ this.applySourceMaps();
+ this.map = opts.sourcemap === 'generator' ? this.map : this.map.toJSON();
+ return this;
+ }
+
+ this.mapVisit(this.ast.nodes);
+ return this;
+ }
+};
+
+/**
+ * Expose `Compiler`
+ */
+
+module.exports = Compiler;
diff --git a/node_modules/snapdragon/lib/parser.js b/node_modules/snapdragon/lib/parser.js
new file mode 100644
index 0000000..a5a9b31
--- /dev/null
+++ b/node_modules/snapdragon/lib/parser.js
@@ -0,0 +1,533 @@
+'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;
diff --git a/node_modules/snapdragon/lib/position.js b/node_modules/snapdragon/lib/position.js
new file mode 100644
index 0000000..c859696
--- /dev/null
+++ b/node_modules/snapdragon/lib/position.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var define = require('define-property');
+
+/**
+ * Store position for a node
+ */
+
+module.exports = function Position(start, parser) {
+ this.start = start;
+ this.end = { line: parser.line, column: parser.column };
+ define(this, 'content', parser.orig);
+ define(this, 'source', parser.options.source);
+};
diff --git a/node_modules/snapdragon/lib/source-maps.js b/node_modules/snapdragon/lib/source-maps.js
new file mode 100644
index 0000000..d8e638b
--- /dev/null
+++ b/node_modules/snapdragon/lib/source-maps.js
@@ -0,0 +1,145 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var define = require('define-property');
+var utils = require('./utils');
+
+/**
+ * Expose `mixin()`.
+ * This code is based on `source-maps-support.js` in reworkcss/css
+ * https://github.com/reworkcss/css/blob/master/lib/stringify/source-map-support.js
+ * Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+ */
+
+module.exports = mixin;
+
+/**
+ * Mixin source map support into `compiler`.
+ *
+ * @param {Object} `compiler`
+ * @api public
+ */
+
+function mixin(compiler) {
+ define(compiler, '_comment', compiler.comment);
+ compiler.map = new utils.SourceMap.SourceMapGenerator();
+ compiler.position = { line: 1, column: 1 };
+ compiler.content = {};
+ compiler.files = {};
+
+ for (var key in exports) {
+ define(compiler, key, exports[key]);
+ }
+}
+
+/**
+ * Update position.
+ *
+ * @param {String} str
+ */
+
+exports.updatePosition = function(str) {
+ var lines = str.match(/\n/g);
+ if (lines) this.position.line += lines.length;
+ var i = str.lastIndexOf('\n');
+ this.position.column = ~i ? str.length - i : this.position.column + str.length;
+};
+
+/**
+ * Emit `str` with `position`.
+ *
+ * @param {String} str
+ * @param {Object} [pos]
+ * @return {String}
+ */
+
+exports.emit = function(str, node) {
+ var position = node.position || {};
+ var source = position.source;
+ if (source) {
+ if (position.filepath) {
+ source = utils.unixify(position.filepath);
+ }
+
+ this.map.addMapping({
+ source: source,
+ generated: {
+ line: this.position.line,
+ column: Math.max(this.position.column - 1, 0)
+ },
+ original: {
+ line: position.start.line,
+ column: position.start.column - 1
+ }
+ });
+
+ if (position.content) {
+ this.addContent(source, position);
+ }
+ if (position.filepath) {
+ this.addFile(source, position);
+ }
+
+ this.updatePosition(str);
+ this.output += str;
+ }
+ return str;
+};
+
+/**
+ * Adds a file to the source map output if it has not already been added
+ * @param {String} `file`
+ * @param {Object} `pos`
+ */
+
+exports.addFile = function(file, position) {
+ if (typeof position.content !== 'string') return;
+ if (Object.prototype.hasOwnProperty.call(this.files, file)) return;
+ this.files[file] = position.content;
+};
+
+/**
+ * Adds a content source to the source map output if it has not already been added
+ * @param {String} `source`
+ * @param {Object} `position`
+ */
+
+exports.addContent = function(source, position) {
+ if (typeof position.content !== 'string') return;
+ if (Object.prototype.hasOwnProperty.call(this.content, source)) return;
+ this.map.setSourceContent(source, position.content);
+};
+
+/**
+ * Applies any original source maps to the output and embeds the source file
+ * contents in the source map.
+ */
+
+exports.applySourceMaps = function() {
+ Object.keys(this.files).forEach(function(file) {
+ var content = this.files[file];
+ this.map.setSourceContent(file, content);
+
+ if (this.options.inputSourcemaps === true) {
+ var originalMap = utils.sourceMapResolve.resolveSync(content, file, fs.readFileSync);
+ if (originalMap) {
+ var map = new utils.SourceMap.SourceMapConsumer(originalMap.map);
+ var relativeTo = originalMap.sourcesRelativeTo;
+ this.map.applySourceMap(map, file, utils.unixify(path.dirname(relativeTo)));
+ }
+ }
+ }, this);
+};
+
+/**
+ * Process comments, drops sourceMap comments.
+ * @param {Object} node
+ */
+
+exports.comment = function(node) {
+ if (/^# sourceMappingURL=/.test(node.comment)) {
+ return this.emit('', node.position);
+ }
+ return this._comment(node);
+};
diff --git a/node_modules/snapdragon/lib/utils.js b/node_modules/snapdragon/lib/utils.js
new file mode 100644
index 0000000..33f07e1
--- /dev/null
+++ b/node_modules/snapdragon/lib/utils.js
@@ -0,0 +1,48 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+exports.extend = require('extend-shallow');
+exports.SourceMap = require('source-map');
+exports.sourceMapResolve = require('source-map-resolve');
+
+/**
+ * Convert backslash in the given string to forward slashes
+ */
+
+exports.unixify = function(fp) {
+ return fp.split(/\\+/).join('/');
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ *
+ * @param {String} `str`
+ * @return {Boolean}
+ */
+
+exports.isString = function(str) {
+ return str && typeof str === 'string';
+};
+
+/**
+ * Cast `val` to an array
+ * @return {Array}
+ */
+
+exports.arrayify = function(val) {
+ if (typeof val === 'string') return [val];
+ return val ? (Array.isArray(val) ? val : [val]) : [];
+};
+
+/**
+ * Get the last `n` element from the given `array`
+ * @param {Array} `array`
+ * @return {*}
+ */
+
+exports.last = function(arr, n) {
+ return arr[arr.length - (n || 1)];
+};