1 files changed, 174 insertions, 0 deletions
diff --git a/node_modules/snapdragon/index.js b/node_modules/snapdragon/index.js
new file mode 100644
index 0000000..235b464
--- /dev/null
+++ b/node_modules/snapdragon/index.js
@@ -0,0 +1,174 @@
+'use strict';
+
+var Base = require('base');
+var define = require('define-property');
+var Compiler = require('./lib/compiler');
+var Parser = require('./lib/parser');
+var utils = require('./lib/utils');
+var regexCache = {};
+var cache = {};
+
+/**
+ * Create a new instance of `Snapdragon` with the given `options`.
+ *
+ * ```js
+ * var snapdragon = new Snapdragon();
+ * ```
+ *
+ * @param {Object} `options`
+ * @api public
+ */
+
+function Snapdragon(options) {
+  Base.call(this, null, options);
+  this.options = utils.extend({source: 'string'}, this.options);
+  this.compiler = new Compiler(this.options);
+  this.parser = new Parser(this.options);
+
+  Object.defineProperty(this, 'compilers', {
+    get: function() {
+      return this.compiler.compilers;
+    }
+  });
+
+  Object.defineProperty(this, 'parsers', {
+    get: function() {
+      return this.parser.parsers;
+    }
+  });
+
+  Object.defineProperty(this, 'regex', {
+    get: function() {
+      return this.parser.regex;
+    }
+  });
+}
+
+/**
+ * Inherit Base
+ */
+
+Base.extend(Snapdragon);
+
+/**
+ * Add a parser to `snapdragon.parsers` for capturing the given `type` using
+ * the specified regex or parser function. A function is useful if you need
+ * to customize how the token is created and/or have access to the parser
+ * instance to check options, etc.
+ *
+ * ```js
+ * snapdragon
+ *   .capture('slash', /^\//)
+ *   .capture('dot', function() {
+ *     var pos = this.position();
+ *     var m = this.match(/^\./);
+ *     if (!m) return;
+ *     return pos({
+ *       type: 'dot',
+ *       val: m[0]
+ *     });
+ *   });
+ * ```
+ * @param {String} `type`
+ * @param {RegExp|Function} `regex`
+ * @return {Object} Returns the parser instance for chaining
+ * @api public
+ */
+
+Snapdragon.prototype.capture = function() {
+  return this.parser.capture.apply(this.parser, arguments);
+};
+
+/**
+ * Register a plugin `fn`.
+ *
+ * ```js
+ * var snapdragon = new Snapdgragon([options]);
+ * snapdragon.use(function() {
+ *   console.log(this);          //<= snapdragon instance
+ *   console.log(this.parser);   //<= parser instance
+ *   console.log(this.compiler); //<= compiler instance
+ * });
+ * ```
+ * @param {Object} `fn`
+ * @api public
+ */
+
+Snapdragon.prototype.use = function(fn) {
+  fn.call(this, this);
+  return this;
+};
+
+/**
+ * Parse the given `str`.
+ *
+ * ```js
+ * var snapdragon = new Snapdgragon([options]);
+ * // register parsers
+ * snapdragon.parser.use(function() {});
+ *
+ * // parse
+ * var ast = snapdragon.parse('foo/bar');
+ * console.log(ast);
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options` Set `options.sourcemap` to true to enable source maps.
+ * @return {Object} Returns an AST.
+ * @api public
+ */
+
+Snapdragon.prototype.parse = function(str, options) {
+  this.options = utils.extend({}, this.options, options);
+  var parsed = this.parser.parse(str, this.options);
+
+  // add non-enumerable parser reference
+  define(parsed, 'parser', this.parser);
+  return parsed;
+};
+
+/**
+ * Compile the given `AST`.
+ *
+ * ```js
+ * var snapdragon = new Snapdgragon([options]);
+ * // register plugins
+ * snapdragon.use(function() {});
+ * // register parser plugins
+ * snapdragon.parser.use(function() {});
+ * // register compiler plugins
+ * snapdragon.compiler.use(function() {});
+ *
+ * // parse
+ * var ast = snapdragon.parse('foo/bar');
+ *
+ * // compile
+ * var res = snapdragon.compile(ast);
+ * console.log(res.output);
+ * ```
+ * @param {Object} `ast`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with an `output` property with the rendered string.
+ * @api public
+ */
+
+Snapdragon.prototype.compile = function(ast, options) {
+  this.options = utils.extend({}, this.options, options);
+  var compiled = this.compiler.compile(ast, this.options);
+
+  // add non-enumerable compiler reference
+  define(compiled, 'compiler', this.compiler);
+  return compiled;
+};
+
+/**
+ * Expose `Snapdragon`
+ */
+
+module.exports = Snapdragon;
+
+/**
+ * Expose `Parser` and `Compiler`
+ */
+
+module.exports.Compiler = Compiler;
+module.exports.Parser = Parser;