[Pkg-javascript-commits] [node-snapdragon] 03/10: embed dependencies
Praveen Arimbrathodiyil
praveen at moszumanska.debian.org
Fri Jan 12 11:26:32 UTC 2018
This is an automated email from the git hooks/post-receive script.
praveen pushed a commit to branch master
in repository node-snapdragon.
commit 2872ce10e4e3d213d02aededdfed7f9b9a16c411
Author: Pirate Praveen <praveen at debian.org>
Date: Fri Jan 12 13:08:35 2018 +0530
embed dependencies
---
debian/node_modules/snapdragon-capture-set/LICENSE | 21 +
.../node_modules/snapdragon-capture-set/README.md | 132 +++
.../node_modules/snapdragon-capture-set/index.js | 157 +++
.../snapdragon-capture-set/package.json | 67 ++
debian/node_modules/snapdragon-capture/LICENSE | 21 +
debian/node_modules/snapdragon-capture/README.md | 105 ++
debian/node_modules/snapdragon-capture/index.js | 71 ++
.../node_modules/snapdragon-capture/package.json | 67 ++
debian/node_modules/snapdragon-node/LICENSE | 21 +
debian/node_modules/snapdragon-node/README.md | 339 ++++++
debian/node_modules/snapdragon-node/index.js | 319 ++++++
debian/node_modules/snapdragon-node/package.json | 75 ++
debian/node_modules/snapdragon-node/utils.js | 20 +
debian/node_modules/snapdragon-util/CHANGELOG.md | 82 ++
debian/node_modules/snapdragon-util/LICENSE | 21 +
debian/node_modules/snapdragon-util/README.md | 840 +++++++++++++++
debian/node_modules/snapdragon-util/index.js | 1117 ++++++++++++++++++++
debian/node_modules/snapdragon-util/package.json | 74 ++
18 files changed, 3549 insertions(+)
diff --git a/debian/node_modules/snapdragon-capture-set/LICENSE b/debian/node_modules/snapdragon-capture-set/LICENSE
new file mode 100644
index 0000000..4a6455c
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture-set/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jon Schlinkert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/debian/node_modules/snapdragon-capture-set/README.md b/debian/node_modules/snapdragon-capture-set/README.md
new file mode 100644
index 0000000..88ebda4
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture-set/README.md
@@ -0,0 +1,132 @@
+# snapdragon-capture-set [](https://www.npmjs.com/package/snapdragon-capture-set) [](https://npmjs.org/package/snapdragon-capture-set) [](https://npmjs.org/package/snapdragon-capture-set) [` method to snapdragon, for matching and capturing substrings that have an `open` and `close`, like braces, brackets, etc
+
+<details>
+<summary><strong>Table of Contents</strong></summary>
+- [Install](#install)
+- [Usage](#usage)
+- [API](#api)
+- [About](#about)
+</details>
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save snapdragon-capture-set
+```
+
+## Usage
+
+```js
+var Snapdragon = require('snapdragon');
+var captureSet = require('snapdragon-capture-set');
+var parser = new Snapdragon.Parser()
+ .use(captureSet())
+ .captureSet('brace', /^\{/, /^\}/)
+ .set('text', function() {
+ var pos = this.position();
+ var m = this.match(/^[^{}]/);
+ if (!m) return;
+ return pos({
+ type: 'text',
+ val: m[0]
+ });
+ });
+
+var ast = parser.parse('a{b,{c,d},e}f');
+console.log(ast.nodes[2]);
+// Node {
+// type: 'brace',
+// nodes:
+// [ Node { type: 'brace.open', val: '{', position: [Object] },
+// Node { type: 'text', val: 'b', position: [Object] },
+// Node { type: 'text', val: ',', position: [Object] },
+// Node { type: 'brace', nodes: [Object], position: [Object] },
+// Node { type: 'text', val: ',', position: [Object] },
+// Node { type: 'text', val: 'e', position: [Object] },
+// Node { type: 'brace.close', val: '}', position: [Object] } ],
+// position: Position { start: { line: 1, column: 2 }, end: { line: 1, column: 3 } } }
+```
+
+## API
+
+**Example**
+
+```js
+var Snapdragon = require('snapdragon');
+var captureSet = require('snapdragon-capture-set');
+
+// snapdragon
+var snapdragon = new Snapdragon();
+snapdragon.use(captureSet());
+
+// parser
+snapdragon.parser.use(captureSet());
+```
+
+### [captureSet](index.js#L52)
+
+Create a node of the given `type` using the specified regex or function.
+
+**Params**
+
+* `type` **{String}**
+* `regex` **{RegExp|Function}**: Pass the regex to use for capturing the `open` and `close` nodes.
+* `returns` **{Object}**: Returns the parser instance for chaining
+
+**Example**
+
+```js
+parser.captureSet('brace', /^\{/, /^\}/);
+```
+
+## About
+
+### Related projects
+
+* [snapdragon-capture](https://www.npmjs.com/package/snapdragon-capture): Snapdragon plugin that adds a capture method to the parser instance. | [homepage](https://github.com/jonschlinkert/snapdragon-capture "Snapdragon plugin that adds a capture method to the parser instance.")
+* [snapdragon-node](https://www.npmjs.com/package/snapdragon-node): Snapdragon utility for creating a new AST node in custom code, such as plugins. | [homepage](https://github.com/jonschlinkert/snapdragon-node "Snapdragon utility for creating a new AST node in custom code, such as plugins.")
+* [snapdragon-util](https://www.npmjs.com/package/snapdragon-util): Utilities for the snapdragon parser/compiler. | [homepage](https://github.com/jonschlinkert/snapdragon-util "Utilities for the snapdragon parser/compiler.")
+
+### Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+### Building docs
+
+_(This document was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme) (a [verb](https://github.com/verbose/verb) generator), please don't edit the readme directly. Any changes to the readme must be made in [.verb.md](.verb.md).)_
+
+To generate the readme and API documentation with [verb](https://github.com/verbose/verb):
+
+```sh
+$ npm install -g verb verb-generate-readme && verb
+```
+
+### Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm install -d && npm test
+```
+
+### Author
+
+**Jon Schlinkert**
+
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2017, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT license](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.4.1, on January 21, 2017._
\ No newline at end of file
diff --git a/debian/node_modules/snapdragon-capture-set/index.js b/debian/node_modules/snapdragon-capture-set/index.js
new file mode 100644
index 0000000..55d5404
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture-set/index.js
@@ -0,0 +1,157 @@
+'use strict';
+
+var Node = require('snapdragon-node');
+var extend = require('extend-shallow');
+
+/**
+ * Register the plugin with `snapdragon.use()` or `snapdragon.parser.use()`.
+ *
+ * ```js
+ * var Snapdragon = require('snapdragon');
+ * var captureSet = require('snapdragon-capture-set');
+ *
+ * // snapdragon
+ * var snapdragon = new Snapdragon();
+ * snapdragon.use(captureSet());
+ *
+ * // parser
+ * snapdragon.parser.use(captureSet());
+ * ```
+ * @api public
+ */
+
+module.exports = function(options) {
+ return function(snapdragon) {
+ if (snapdragon.isSnapdragon) {
+ snapdragon.parser.use(captureSet(options));
+ snapdragon.define('captureSet', function() {
+ return this.parser.captureSet.apply(this.parser, arguments);
+ });
+
+ } else if (snapdragon.isParser) {
+ snapdragon.use(captureSet(options));
+
+ } else {
+ throw new Error('expected an instance of snapdragon or snapdragon.parser');
+ }
+ };
+};
+
+/**
+ * Create a node of the given `type` using the specified regex or function.
+ *
+ * ```js
+ * parser.captureSet('brace', /^\{/, /^\}/);
+ * ```
+ * @param {String} `type`
+ * @param {RegExp|Function} `regex` Pass the regex to use for capturing the `open` and `close` nodes.
+ * @return {Object} Returns the parser instance for chaining
+ * @api public
+ */
+
+function captureSet(options) {
+ return function(parser) {
+ parser.define('captureOpen', function(type, regex, fn) {
+ this.sets[type] = this.sets[type] || [];
+
+ // noop, we really only need the `.open` and `.close` visitors
+ this.set(type, function() {});
+
+ // create the `open` visitor for "type"
+ this.set(type + '.open', function() {
+ var pos = this.position();
+ var match = this.match(regex);
+ if (!match || !match[0]) return;
+
+ this.setCount++;
+
+ // get the last node, either from `this.stack` or `this.ast.nodes`,
+ // so we can push our "parent" node onto the `nodes` array of
+ // that node. We don't want to just push it onto the ast, because
+ // we need to easily be able to pop it off of a stack when we
+ // get the "close" node
+ var prev = this.prev();
+
+ // create the "parent" node (ex: "brace")
+ var parent = pos(new Node({
+ type: type,
+ nodes: []
+ }));
+
+ // create the "open" node (ex: "brace.open")
+ var open = pos(new Node({
+ type: type + '.open',
+ val: match[0]
+ }));
+
+ // push "open" node onto `parent.nodes`, and create
+ // a reference to parent on `open.parent`
+ parent.pushNode(open);
+
+ // add a non-enumerable reference to the "match" arguments
+ open.define('match', match);
+ parent.define('match', match);
+
+ if (typeof fn === 'function') {
+ fn.call(this, open, parent);
+ }
+
+ this.push(type, parent);
+ prev.pushNode(parent);
+ });
+
+ return this;
+ });
+
+ parser.define('captureClose', function(type, regex, fn) {
+ if (typeof this.sets[type] === 'undefined') {
+ throw new Error('an `.open` type is not registered for ' + type);
+ }
+
+ var opts = extend({}, this.options, options);
+
+ // create the `close` visitor for "type"
+ this.set(type + '.close', function() {
+ var pos = this.position();
+ var match = this.match(regex);
+ if (!match || !match[0]) return;
+
+ var parent = this.pop(type);
+ var close = pos(new Node({
+ type: type + '.close',
+ val: match[0]
+ }));
+
+ if (!this.isType(parent, type)) {
+ if (opts.strict) {
+ throw new Error('missing opening "' + type + '"');
+ }
+
+ this.setCount--;
+ close.define('escaped', true);
+ return close;
+ }
+
+ if (close.suffix === '\\') {
+ parent.define('escaped', true);
+ close.define('escaped', true);
+ }
+
+ parent.pushNode(close);
+ });
+
+ return this;
+ });
+
+ /**
+ * Create a parser with open and close for parens,
+ * brackets or braces
+ */
+
+ parser.define('captureSet', function(type, openRegex, closeRegex, fn) {
+ this.captureOpen(type, openRegex, fn);
+ this.captureClose(type, closeRegex, fn);
+ return this;
+ });
+ };
+}
diff --git a/debian/node_modules/snapdragon-capture-set/package.json b/debian/node_modules/snapdragon-capture-set/package.json
new file mode 100644
index 0000000..fe57329
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture-set/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "snapdragon-capture-set",
+ "description": "Plugin that adds a `.captureSet()` method to snapdragon, for matching and capturing substrings that have an `open` and `close`, like braces, brackets, etc",
+ "version": "1.0.1",
+ "homepage": "https://github.com/jonschlinkert/snapdragon-capture-set",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "repository": "jonschlinkert/snapdragon-capture-set",
+ "bugs": {
+ "url": "https://github.com/jonschlinkert/snapdragon-capture-set/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=4"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "dependencies": {
+ "extend-shallow": "^2.0.1",
+ "snapdragon-node": "^1.0.0"
+ },
+ "devDependencies": {
+ "gulp-format-md": "^0.1.11",
+ "mocha": "^3.2.0",
+ "snapdragon": "^0.9.0",
+ "snapdragon-util": "^1.0.1"
+ },
+ "keywords": [
+ "capture",
+ "match",
+ "parse",
+ "parser",
+ "plugin",
+ "set",
+ "snapdragon",
+ "snapdragonplugin",
+ "visitor"
+ ],
+ "verb": {
+ "toc": "collapsible",
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "related": {
+ "list": [
+ "snapdragon-capture",
+ "snapdragon-node",
+ "snapdragon-util"
+ ]
+ },
+ "reflinks": [
+ "verb",
+ "verb-generate-readme"
+ ],
+ "lint": {
+ "reflinks": true
+ }
+ }
+}
diff --git a/debian/node_modules/snapdragon-capture/LICENSE b/debian/node_modules/snapdragon-capture/LICENSE
new file mode 100644
index 0000000..4a6455c
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jon Schlinkert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/debian/node_modules/snapdragon-capture/README.md b/debian/node_modules/snapdragon-capture/README.md
new file mode 100644
index 0000000..51ecf8e
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture/README.md
@@ -0,0 +1,105 @@
+# snapdragon-capture [](https://www.npmjs.com/package/snapdragon-capture) [](https://npmjs.org/package/snapdragon-capture) [](https://npmjs.org/package/snapdragon-capture) [:
+
+```sh
+$ npm install --save snapdragon-capture
+```
+
+## Usage
+
+Requires [snapdragon](https://github.com/jonschlinkert/snapdragon) v0.9.0 or higher.
+
+```js
+var capture = require('snapdragon-capture');
+var Snapdragon = require('snapdragon');
+var snapdragon = new Snapdragon();
+snapdragon.use(capture());
+```
+
+## API
+
+**Example**
+
+```js
+var Snapdragon = require('snapdragon');
+var capture = require('snapdragon-capture');
+var parser = new Snapdragon.Parser();
+parser.use(capture());
+```
+
+### [capture](index.js#L55)
+
+Create a node of the given `type` using the specified regex or function.
+
+**Params**
+
+* `type` **{String}**
+* `regex` **{RegExp|Function}**: Pass the regex to use for capturing. Pass a function if you need access to the parser instance.
+* `returns` **{Object}**: Returns the parser instance for chaining
+
+**Example**
+
+```js
+parser
+ .capture('slash', /^\//)
+ .capture('comma', /^,/)
+ .capture('foo', function() {
+ var pos = this.position();
+ var match = this.match(/^\./);
+ if (match) {
+ return pos(this.node(match[0]));
+ }
+ });
+```
+
+## About
+
+### Related projects
+
+* [snapdragon-util](https://www.npmjs.com/package/snapdragon-util): Utilities for the snapdragon parser/compiler. | [homepage](https://github.com/jonschlinkert/snapdragon-util "Utilities for the snapdragon parser/compiler.")
+* [snapdragon](https://www.npmjs.com/package/snapdragon): Easy-to-use plugin system for creating powerful, fast and versatile parsers and compilers, with built-in source-map… [more](https://github.com/jonschlinkert/snapdragon) | [homepage](https://github.com/jonschlinkert/snapdragon "Easy-to-use plugin system for creating powerful, fast and versatile parsers and compilers, with built-in source-map support.")
+
+### Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+### Building docs
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+### Running tests
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+### Author
+
+**Jon Schlinkert**
+
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2017, [Jon Schlinkert](https://github.com/jonschlinkert).
+MIT
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.4.2, on February 08, 2017._
\ No newline at end of file
diff --git a/debian/node_modules/snapdragon-capture/index.js b/debian/node_modules/snapdragon-capture/index.js
new file mode 100644
index 0000000..6123471
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture/index.js
@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * Adds a `.capture` method to a [snapdragon][] `Parser` instance. Wraps
+ * the `.set` method to simplify the interface for creating parsers.
+ *
+ * ```js
+ * var Snapdragon = require('snapdragon');
+ * var capture = require('snapdragon-capture');
+ * var parser = new Snapdragon.Parser();
+ * parser.use(capture());
+ * ```
+ *
+ * @api public
+ */
+
+module.exports = function(options) {
+ return function(snapdragon) {
+ if (snapdragon.isSnapdragon) {
+ snapdragon.parser.define('capture', capture);
+ snapdragon.define('capture', function() {
+ return this.parser.capture.apply(this.parser, arguments);
+ });
+
+ } else if (snapdragon.isParser) {
+ snapdragon.define('capture', capture);
+
+ } else {
+ throw new Error('expected an instance of snapdragon or snapdragon.parser');
+ }
+ };
+};
+
+/**
+ * Create a node of the given `type` using the specified regex or function.
+ *
+ * ```js
+ * parser
+ * .capture('slash', /^\//)
+ * .capture('comma', /^,/)
+ * .capture('foo', function() {
+ * var pos = this.position();
+ * var match = this.match(/^\./);
+ * if (match) {
+ * return pos(this.node(match[0]));
+ * }
+ * });
+ * ```
+ * @param {String} `type`
+ * @param {RegExp|Function} `regex` Pass the regex to use for capturing. Pass a function if you need access to the parser instance.
+ * @return {Object} Returns the parser instance for chaining
+ * @api public
+ */
+
+function capture(type, regex) {
+ if (typeof regex === 'function') {
+ return this.set.apply(this, arguments);
+ }
+
+ this.regex.set(type, regex);
+ this.set(type, function() {
+ var pos = this.position();
+ var match = this.match(regex);
+ if (match) {
+ var node = pos(this.node(match[0], type));
+ node.match = match;
+ return node;
+ }
+ }.bind(this));
+ return this;
+}
diff --git a/debian/node_modules/snapdragon-capture/package.json b/debian/node_modules/snapdragon-capture/package.json
new file mode 100644
index 0000000..4feb117
--- /dev/null
+++ b/debian/node_modules/snapdragon-capture/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "snapdragon-capture",
+ "description": "Snapdragon plugin that adds a capture method to the parser instance.",
+ "version": "0.2.0",
+ "homepage": "https://github.com/jonschlinkert/snapdragon-capture",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "repository": "jonschlinkert/snapdragon-capture",
+ "bugs": {
+ "url": "https://github.com/jonschlinkert/snapdragon-capture/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=4"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "devDependencies": {
+ "gulp-format-md": "^0.1.11",
+ "mocha": "^3.2.0",
+ "snapdragon": "^0.10.0"
+ },
+ "keywords": [
+ "capture",
+ "compile",
+ "compiler",
+ "convert",
+ "handler",
+ "match",
+ "parse",
+ "parser",
+ "plugin",
+ "render",
+ "set",
+ "snapdragon",
+ "snapdragonplugin",
+ "transform",
+ "visitor"
+ ],
+ "verb": {
+ "toc": false,
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "related": {
+ "list": [
+ "snapdragon",
+ "snapdragon-util"
+ ]
+ },
+ "reflinks": [
+ "verb",
+ "verb-generate-readme"
+ ],
+ "lint": {
+ "reflinks": true
+ }
+ }
+}
diff --git a/debian/node_modules/snapdragon-node/LICENSE b/debian/node_modules/snapdragon-node/LICENSE
new file mode 100644
index 0000000..4a6455c
--- /dev/null
+++ b/debian/node_modules/snapdragon-node/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jon Schlinkert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/debian/node_modules/snapdragon-node/README.md b/debian/node_modules/snapdragon-node/README.md
new file mode 100644
index 0000000..518a6b6
--- /dev/null
+++ b/debian/node_modules/snapdragon-node/README.md
@@ -0,0 +1,339 @@
+# snapdragon-node [](https://www.npmjs.com/package/snapdragon-node) [](https://npmjs.org/package/snapdragon-node) [](https://npmjs.org/package/snapdragon-node) [:
+
+```sh
+$ npm install --save snapdragon-node
+```
+
+## Usage
+
+With [snapdragon](https://github.com/jonschlinkert/snapdragon) v0.9.0 and higher you can use `this.node()` to create a new `Node`, whenever it makes sense.
+
+```js
+var Node = require('snapdragon-node');
+var Snapdragon = require('snapdragon');
+var snapdragon = new Snapdragon();
+
+// example usage inside a parser visitor function
+snapdragon.parser.set('foo', function() {
+ var pos = this.position();
+ // if the regex matches the substring at the current position
+ // on `this.input`, return the match
+ var match = this.match(/foo/);
+ if (match) {
+ // if node.type is not defined on the node, the parser
+ // will automatically add it
+ var node = pos(new Node(match[0]));
+
+ // or, explictly pass a type
+ var node = pos(new Node(match[0], 'bar'));
+ // or
+ var node = pos(new Node({type: 'bar', val: match[0]}));
+ return node;
+ }
+});
+```
+
+## API
+
+### [Node](index.js#L20)
+
+Create a new AST `Node` with the given `val` and `type`.
+
+**Params**
+
+* `val` **{String|Object}**: Pass a matched substring, or an object to merge onto the node.
+* `type` **{String}**: The node type to use when `val` is a string.
+* `returns` **{Object}**: node instance
+
+**Example**
+
+```js
+var node = new Node('*', 'Star');
+var node = new Node({type: 'star', val: '*'});
+```
+
+### [.define](index.js#L50)
+
+Define a non-enumberable property on the node instance.
+
+**Params**
+
+* `name` **{String}**
+* `val` **{any}**
+* `returns` **{Object}**: returns the node instance
+
+**Example**
+
+```js
+var node = new Node();
+node.define('foo', 'something non-enumerable');
+```
+
+### [.pushNode](index.js#L70)
+
+Given node `foo` and node `bar`, push node `bar` onto `foo.nodes`, and set `foo` as `bar.parent`.
+
+**Params**
+
+* `node` **{Object}**
+* `returns` **{undefined}**
+
+**Example**
+
+```js
+var foo = new Node({type: 'foo'});
+var bar = new Node({type: 'bar'});
+foo.pushNode(bar);
+```
+
+### [.addNode](index.js#L82)
+
+Alias for [pushNode](#pushNode) for backwards compatibility with 0.1.0.
+
+### [.unshiftNode](index.js#L101)
+
+Given node `foo` and node `bar`, unshift node `bar` onto `foo.nodes`, and set `foo` as `bar.parent`.
+
+**Params**
+
+* `node` **{Object}**
+* `returns` **{undefined}**
+
+**Example**
+
+```js
+var foo = new Node({type: 'foo'});
+var bar = new Node({type: 'bar'});
+foo.unshiftNode(bar);
+```
+
+### [.getNode](index.js#L123)
+
+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.
+
+**Params**
+
+* `type` **{String}**
+* `returns` **{Object}**: Returns a child node or undefined.
+
+**Example**
+
+```js
+var child = node.getNode(1); //<= index of the node to get
+var child = node.getNode('foo');
+var child = node.getNode(/^(foo|bar)$/);
+var child = node.getNode(['foo', 'bar']);
+```
+
+### [.isType](index.js#L142)
+
+Return true if the node is the given `type`.
+
+**Params**
+
+* `type` **{String}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.hasType](index.js#L164)
+
+Return true if the `node.nodes` has the given `type`.
+
+**Params**
+
+* `type` **{String}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+var foo = new Node({type: 'foo'});
+var bar = new Node({type: 'bar'});
+foo.pushNode(bar);
+
+cosole.log(foo.hasType('qux')); // false
+cosole.log(foo.hasType(/^(qux|bar)$/)); // true
+cosole.log(foo.hasType(['qux', 'bar'])); // true
+```
+
+### [.siblings](index.js#L186)
+
+Get the siblings array, or `null` if it doesn't exist.
+
+* `returns` **{Array}**
+
+**Example**
+
+```js
+var foo = new Node({type: 'foo'});
+var bar = new Node({type: 'bar'});
+var baz = new Node({type: 'baz'});
+foo.pushNode(bar);
+foo.pushNode(baz);
+
+console.log(bar.siblings.length) // 2
+console.log(baz.siblings.length) // 2
+```
+
+### [.prev](index.js#L209)
+
+Get the previous node from the siblings array or `null`.
+
+* `returns` **{Object}**
+
+**Example**
+
+```js
+var foo = new Node({type: 'foo'});
+var bar = new Node({type: 'bar'});
+var baz = new Node({type: 'baz'});
+foo.pushNode(bar);
+foo.pushNode(baz);
+
+console.log(baz.prev.type) // 'bar'
+```
+
+### [.next](index.js#L235)
+
+Get the siblings array, or `null` if it doesn't exist.
+
+* `returns` **{Object}**
+
+**Example**
+
+```js
+var foo = new Node({type: 'foo'});
+var bar = new Node({type: 'bar'});
+var baz = new Node({type: 'baz'});
+foo.pushNode(bar);
+foo.pushNode(baz);
+
+console.log(bar.siblings.length) // 2
+console.log(baz.siblings.length) // 2
+```
+
+### [.index](index.js#L265)
+
+Get the node's current index from `node.parent.nodes`. This should always be correct, even when the parent adds nodes.
+
+* `returns` **{Number}**
+
+**Example**
+
+```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.pushNode(bar);
+foo.pushNode(baz);
+foo.unshiftNode(qux);
+
+console.log(bar.index) // 1
+console.log(baz.index) // 2
+console.log(qux.index) // 0
+```
+
+### [.first](index.js#L290)
+
+Get the first node from `node.nodes`.
+
+* `returns` **{Object}**: The first node, or undefiend
+
+**Example**
+
+```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.pushNode(bar);
+foo.pushNode(baz);
+foo.pushNode(qux);
+
+console.log(foo.first.type) // 'bar'
+```
+
+### [.last](index.js#L315)
+
+Get the last node from `node.nodes`.
+
+* `returns` **{Object}**: The last node, or undefiend
+
+**Example**
+
+```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.pushNode(bar);
+foo.pushNode(baz);
+foo.pushNode(qux);
+
+console.log(foo.last.type) // 'qux'
+```
+
+## About
+
+### Related projects
+
+* [breakdance](https://www.npmjs.com/package/breakdance): Breakdance is a node.js library for converting HTML to markdown. Highly pluggable, flexible and easy… [more](http://breakdance.io) | [homepage](http://breakdance.io "Breakdance is a node.js library for converting HTML to markdown. Highly pluggable, flexible and easy to use. It's time for your markup to get down.")
+* [snapdragon-capture](https://www.npmjs.com/package/snapdragon-capture): Snapdragon plugin that adds a capture method to the parser instance. | [homepage](https://github.com/jonschlinkert/snapdragon-capture "Snapdragon plugin that adds a capture method to the parser instance.")
+* [snapdragon-cheerio](https://www.npmjs.com/package/snapdragon-cheerio): Snapdragon plugin for converting a cheerio AST to a snapdragon AST. | [homepage](https://github.com/jonschlinkert/snapdragon-cheerio "Snapdragon plugin for converting a cheerio AST to a snapdragon AST.")
+* [snapdragon-util](https://www.npmjs.com/package/snapdragon-util): Utilities for the snapdragon parser/compiler. | [homepage](https://github.com/jonschlinkert/snapdragon-util "Utilities for the snapdragon parser/compiler.")
+* [snapdragon](https://www.npmjs.com/package/snapdragon): Easy-to-use plugin system for creating powerful, fast and versatile parsers and compilers, with built-in source-map… [more](https://github.com/jonschlinkert/snapdragon) | [homepage](https://github.com/jonschlinkert/snapdragon "Easy-to-use plugin system for creating powerful, fast and versatile parsers and compilers, with built-in source-map support.")
+
+### Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+### Building docs
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+### Running tests
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+### Author
+
+**Jon Schlinkert**
+
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2017, [Jon Schlinkert](https://github.com/jonschlinkert).
+MIT
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.4.2, on February 15, 2017._
\ No newline at end of file
diff --git a/debian/node_modules/snapdragon-node/index.js b/debian/node_modules/snapdragon-node/index.js
new file mode 100644
index 0000000..90208f2
--- /dev/null
+++ b/debian/node_modules/snapdragon-node/index.js
@@ -0,0 +1,319 @@
+'use strict';
+
+var getters = ['siblings', 'index', 'first', 'last', 'prev', 'next'];
+var utils = require('./utils');
+
+/**
+ * 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
+ */
+
+var Node = exports = module.exports = function Node(val, type) {
+ this.define('isNode', true);
+ this.type = null;
+
+ if (utils.isObject(val)) {
+ for (var key in val) {
+ if (getters.indexOf(key) === -1) {
+ this[key] = val[key];
+ }
+ }
+ } else {
+ this.type = type;
+ this.val = val;
+ }
+};
+
+/**
+ * Define a non-enumberable property on the node instance.
+ *
+ * ```js
+ * var node = new Node();
+ * node.define('foo', 'something non-enumerable');
+ * ```
+ * @name .define
+ * @param {String} `name`
+ * @param {any} `val`
+ * @return {Object} returns the node instance
+ * @api public
+ */
+
+Node.prototype.define = function(name, val) {
+ utils.define(this, name, val);
+ return this;
+};
+
+/**
+ * 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.pushNode(bar);
+ * ```
+ * @name .pushNode
+ * @param {Object} `node`
+ * @return {undefined}
+ * @api public
+ */
+
+Node.prototype.pushNode = function(node) {
+ this.nodes = this.nodes || [];
+ utils.define(node, 'parent', this);
+ this.nodes.push(node);
+};
+
+/**
+ * Alias for [pushNode](#pushNode) for backwards compatibility with 0.1.0.
+ * @name .addNode
+ * @api public
+ */
+
+Node.prototype.addNode = function(node) {
+ return this.pushNode(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.unshiftNode(bar);
+ * ```
+ * @name .unshiftNode
+ * @param {Object} `node`
+ * @return {undefined}
+ * @api public
+ */
+
+Node.prototype.unshiftNode = function(node) {
+ this.nodes = this.nodes || [];
+ utils.define(node, 'parent', this);
+ this.nodes.unshift(node);
+};
+
+/**
+ * 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.getNode(1); //<= index of the node to get
+ * var child = node.getNode('foo');
+ * var child = node.getNode(/^(foo|bar)$/);
+ * var child = node.getNode(['foo', 'bar']);
+ * ```
+ * @name .getNode
+ * @param {String} `type`
+ * @return {Object} Returns a child node or undefined.
+ * @api public
+ */
+
+Node.prototype.getNode = function(type) {
+ return utils.su.getNode(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
+ * ```
+ * @name .isType
+ * @param {String} `type`
+ * @return {Boolean}
+ * @api public
+ */
+
+Node.prototype.isType = function(type) {
+ return utils.su.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.pushNode(bar);
+ *
+ * cosole.log(foo.hasType('qux')); // false
+ * cosole.log(foo.hasType(/^(qux|bar)$/)); // true
+ * cosole.log(foo.hasType(['qux', 'bar'])); // true
+ * ```
+ * @name .hasType
+ * @param {String} `type`
+ * @return {Boolean}
+ * @api public
+ */
+
+Node.prototype.hasType = function(type) {
+ return utils.su.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.pushNode(bar);
+ * foo.pushNode(baz);
+ *
+ * console.log(bar.siblings.length) // 2
+ * console.log(baz.siblings.length) // 2
+ * ```
+ * @name .siblings
+ * @return {Array}
+ * @api public
+ */
+
+Object.defineProperty(Node.prototype, 'siblings', {
+ get: function() {
+ return this.parent ? this.parent.nodes : null;
+ }
+});
+
+/**
+ * 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.pushNode(bar);
+ * foo.pushNode(baz);
+ *
+ * console.log(baz.prev.type) // 'bar'
+ * ```
+ * @name .prev
+ * @return {Object}
+ * @api public
+ */
+
+Object.defineProperty(Node.prototype, 'prev', {
+ get: function() {
+ return this.parent && this.siblings
+ ? this.siblings[this.index - 1] || this.parent.prev
+ : 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.pushNode(bar);
+ * foo.pushNode(baz);
+ *
+ * console.log(bar.siblings.length) // 2
+ * console.log(baz.siblings.length) // 2
+ * ```
+ * @name .next
+ * @return {Object}
+ * @api public
+ */
+
+Object.defineProperty(Node.prototype, 'next', {
+ get: function() {
+ return this.parent && this.siblings
+ ? this.siblings[this.index + 1] || this.parent.next
+ : 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.pushNode(bar);
+ * foo.pushNode(baz);
+ * foo.unshiftNode(qux);
+ *
+ * console.log(bar.index) // 1
+ * console.log(baz.index) // 2
+ * console.log(qux.index) // 0
+ * ```
+ * @name .index
+ * @return {Number}
+ * @api public
+ */
+
+Object.defineProperty(Node.prototype, 'index', {
+ get: function() {
+ return this.siblings ? this.siblings.indexOf(this) : -1;
+ }
+});
+
+/**
+ * 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.pushNode(bar);
+ * foo.pushNode(baz);
+ * foo.pushNode(qux);
+ *
+ * console.log(foo.first.type) // 'bar'
+ * ```
+ * @name .first
+ * @return {Object} The first node, or undefiend
+ * @api public
+ */
+
+Object.defineProperty(Node.prototype, 'first', {
+ get: function() {
+ return utils.su.arrayify(this.nodes)[0];
+ }
+});
+
+/**
+ * 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.pushNode(bar);
+ * foo.pushNode(baz);
+ * foo.pushNode(qux);
+ *
+ * console.log(foo.last.type) // 'qux'
+ * ```
+ * @name .last
+ * @return {Object} The last node, or undefiend
+ * @api public
+ */
+
+Object.defineProperty(Node.prototype, 'last', {
+ get: function() {
+ return utils.su.last(utils.su.arrayify(this.nodes));
+ }
+});
diff --git a/debian/node_modules/snapdragon-node/package.json b/debian/node_modules/snapdragon-node/package.json
new file mode 100644
index 0000000..1129f3c
--- /dev/null
+++ b/debian/node_modules/snapdragon-node/package.json
@@ -0,0 +1,75 @@
+{
+ "name": "snapdragon-node",
+ "description": "Snapdragon utility for creating a new AST node in custom code, such as plugins.",
+ "version": "1.0.6",
+ "homepage": "https://github.com/jonschlinkert/snapdragon-node",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "repository": "jonschlinkert/snapdragon-node",
+ "bugs": {
+ "url": "https://github.com/jonschlinkert/snapdragon-node/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js",
+ "utils.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=4.7"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "dependencies": {
+ "define-property": "^0.2.5",
+ "isobject": "^3.0.0",
+ "lazy-cache": "^2.0.2",
+ "snapdragon-util": "^1.0.3"
+ },
+ "devDependencies": {
+ "gulp-format-md": "^0.1.11",
+ "mocha": "^3.2.0",
+ "snapdragon": "^0.9.1",
+ "snapdragon-capture-set": "^1.0.1"
+ },
+ "keywords": [
+ "ast",
+ "compile",
+ "compiler",
+ "convert",
+ "node",
+ "parse",
+ "parser",
+ "plugin",
+ "render",
+ "snapdragon",
+ "snapdragonplugin",
+ "token",
+ "transform"
+ ],
+ "verb": {
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "related": {
+ "list": [
+ "snapdragon",
+ "snapdragon-capture",
+ "snapdragon-util",
+ "snapdragon-cheerio",
+ "breakdance"
+ ]
+ },
+ "reflinks": [
+ "verb",
+ "verb-generate-readme"
+ ],
+ "lint": {
+ "reflinks": true
+ }
+ }
+}
diff --git a/debian/node_modules/snapdragon-node/utils.js b/debian/node_modules/snapdragon-node/utils.js
new file mode 100644
index 0000000..341c9d2
--- /dev/null
+++ b/debian/node_modules/snapdragon-node/utils.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var utils = require('lazy-cache')(require);
+var fn = require;
+require = utils;
+
+/**
+ * Lazily required module dependencies
+ */
+
+require('define-property', 'define');
+require('isobject', 'isObject');
+require('snapdragon-util', 'su');
+require = fn;
+
+/**
+ * Expose `utils` modules
+ */
+
+module.exports = utils;
diff --git a/debian/node_modules/snapdragon-util/CHANGELOG.md b/debian/node_modules/snapdragon-util/CHANGELOG.md
new file mode 100644
index 0000000..cb9131c
--- /dev/null
+++ b/debian/node_modules/snapdragon-util/CHANGELOG.md
@@ -0,0 +1,82 @@
+# Release history
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+<details>
+ <summary><strong>Guiding Principles</strong></summary>
+
+- Changelogs are for humans, not machines.
+- There should be an entry for every single version.
+- The same types of changes should be grouped.
+- Versions and sections should be linkable.
+- The latest version comes first.
+- The release date of each versions is displayed.
+- Mention whether you follow Semantic Versioning.
+
+</details>
+
+<details>
+ <summary><strong>Types of changes</strong></summary>
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_):
+
+* `added`: for new features
+* `changed`: for changes in existing functionality
+* `deprecated`: for once-stable features removed in upcoming releases
+* `removed`: for deprecated features removed in this release
+* `fixed`: for any bug fixes
+
+Custom labels used in this repository:
+
+* `dependencies`: bumps dependencies
+* `housekeeping`: code re-organization, minor edits, or other changes that don't fit in one of the other categories.
+
+</details>
+
+
+### [5.0.0] - 2018-01-11
+
+**Changes**
+
+- Adds support for `node.value`, in anticipation of snapdragon v1.0.0.
+
+
+### [4.0.0] - 2017-11-01
+
+**Dependencies**
+
+- Updated `kind-of` to version 6.0
+
+### [3.0.0] - 2017-05-01
+
+**Changed**
+
+- `.emit` was renamed to [.append](README.md#append)
+- `.addNode` was renamed to [.pushNode](README.md#pushNode)
+- `.getNode` was renamed to [.findNode](README.md#findNode)
+- `.isEmptyNodes` was renamed to [.isEmpty](README.md#isEmpty): also now works with `node.nodes` and/or `node.val`
+
+**Added**
+
+- [.identity](README.md#identity)
+- [.removeNode](README.md#removeNode)
+- [.shiftNode](README.md#shiftNode)
+- [.popNode](README.md#popNode)
+
+### 0.1.0
+
+First release.
+
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
+
+[5.0.0]: https://github.com/here-be/snapdragon-util/compare/4.0.0...5.0.0
+[4.0.0]: https://github.com/here-be/snapdragon-util/compare/4.0.0...3.0.0
+[3.0.1]: https://github.com/here-be/snapdragon-util/compare/3.0.0...3.0.1
+[3.0.0]: https://github.com/here-be/snapdragon-util/compare/2.1.1...3.0.0
+
+[Unreleased]: https://github.com/here-be/snapdragon-util/compare/0.1.1...HEAD
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
+
diff --git a/debian/node_modules/snapdragon-util/LICENSE b/debian/node_modules/snapdragon-util/LICENSE
new file mode 100644
index 0000000..1f288f9
--- /dev/null
+++ b/debian/node_modules/snapdragon-util/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2018, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/debian/node_modules/snapdragon-util/README.md b/debian/node_modules/snapdragon-util/README.md
new file mode 100644
index 0000000..11536f0
--- /dev/null
+++ b/debian/node_modules/snapdragon-util/README.md
@@ -0,0 +1,840 @@
+# snapdragon-util [](https://www.npmjs.com/package/snapdragon-util) [](https://npmjs.org/package/snapdragon-util) [](https://npmjs.org/package/snapdragon-util) [, and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save snapdragon-util
+```
+
+## Usage
+
+```js
+var util = require('snapdragon-util');
+```
+
+## API
+
+### [.isNode](index.js#L20)
+
+Returns true if the given value is a node.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+var Node = require('snapdragon-node');
+var node = new Node({type: 'foo'});
+console.log(utils.isNode(node)); //=> true
+console.log(utils.isNode({})); //=> false
+```
+
+### [.noop](index.js#L36)
+
+Emit an empty string for the given `node`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{undefined}**
+
+**Example**
+
+```js
+// do nothing for beginning-of-string
+snapdragon.compiler.set('bos', utils.noop);
+```
+
+### [.value](index.js#L54)
+
+Returns `node.value` or `node.val`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{String}**: returns
+
+**Example**
+
+```js
+const star = new Node({type: 'star', value: '*'});
+const slash = new Node({type: 'slash', val: '/'});
+console.log(utils.value(star)) //=> '*'
+console.log(utils.value(slash)) //=> '/'
+```
+
+### [.identity](index.js#L72)
+
+Append `node.value` to `compiler.output`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{undefined}**
+
+**Example**
+
+```js
+snapdragon.compiler.set('text', utils.identity);
+```
+
+### [.append](index.js#L95)
+
+Previously named `.emit`, this method appends the given `value` to `compiler.output` for the given node. Useful when you know what value should be appended advance, regardless of the actual value of `node.value`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Function}**: Returns a compiler middleware function.
+
+**Example**
+
+```js
+snapdragon.compiler
+ .set('i', function(node) {
+ this.mapVisit(node);
+ })
+ .set('i.open', utils.append('<i>'))
+ .set('i.close', utils.append('</i>'))
+```
+
+### [.toNoop](index.js#L118)
+
+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.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `nodes` **{Array}**: Optionally pass a new `nodes` value, to replace the existing `node.nodes` array.
+
+**Example**
+
+```js
+utils.toNoop(node);
+// convert `node.nodes` to the given value instead of deleting it
+utils.toNoop(node, []);
+```
+
+### [.visit](index.js#L147)
+
+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.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `fn` **{Function}**
+* `returns` **{Object}**: returns the node after recursively visiting all child nodes.
+
+**Example**
+
+```js
+snapdragon.compiler.set('i', function(node) {
+ utils.visit(node, function(childNode) {
+ // do stuff with "childNode"
+ return childNode;
+ });
+});
+```
+
+### [.mapVisit](index.js#L174)
+
+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.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `options` **{Object}**
+* `fn` **{Function}**
+* `returns` **{Object}**: returns the node
+
+**Example**
+
+```js
+snapdragon.compiler.set('i', function(node) {
+ utils.mapVisit(node, function(childNode) {
+ // do stuff with "childNode"
+ return childNode;
+ });
+});
+```
+
+### [.addOpen](index.js#L213)
+
+Unshift an `*.open` node onto `node.nodes`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `Node` **{Function}**: (required) Node constructor function from [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node).
+* `filter` **{Function}**: Optionaly specify a filter function to exclude the node.
+* `returns` **{Object}**: Returns the created opening node.
+
+**Example**
+
+```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', value: '' };
+
+ // 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;
+ }
+});
+```
+
+### [.addClose](index.js#L263)
+
+Push a `*.close` node onto `node.nodes`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `Node` **{Function}**: (required) Node constructor function from [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node).
+* `filter` **{Function}**: Optionaly specify a filter function to exclude the node.
+* `returns` **{Object}**: Returns the created closing node.
+
+**Example**
+
+```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', value: '' };
+
+ // no need to return a node, since the parent
+ // was already added to the AST
+ return;
+ }
+});
+```
+
+### [.wrapNodes](index.js#L293)
+
+Wraps the given `node` with `*.open` and `*.close` nodes.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `Node` **{Function}**: (required) Node constructor function from [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node).
+* `filter` **{Function}**: Optionaly specify a filter function to exclude the node.
+* `returns` **{Object}**: Returns the node
+
+### [.pushNode](index.js#L318)
+
+Push the given `node` onto `parent.nodes`, and set `parent` as `node.parent.
+
+**Params**
+
+* `parent` **{Object}**
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Object}**: Returns the child node
+
+**Example**
+
+```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'
+```
+
+### [.unshiftNode](index.js#L348)
+
+Unshift `node` onto `parent.nodes`, and set `parent` as `node.parent.
+
+**Params**
+
+* `parent` **{Object}**
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{undefined}**
+
+**Example**
+
+```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'
+```
+
+### [.popNode](index.js#L381)
+
+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`.
+
+**Params**
+
+* `parent` **{Object}**
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Number|Undefined}**: Returns the length of `node.nodes` or undefined.
+
+**Example**
+
+```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
+```
+
+### [.shiftNode](index.js#L409)
+
+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`.
+
+**Params**
+
+* `parent` **{Object}**
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Number|Undefined}**: Returns the length of `node.nodes` or undefined.
+
+**Example**
+
+```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
+```
+
+### [.removeNode](index.js#L436)
+
+Remove the specified `node` from `parent.nodes`.
+
+**Params**
+
+* `parent` **{Object}**
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Object|undefined}**: Returns the removed node, if successful, or undefined if it does not exist on `parent.nodes`.
+
+**Example**
+
+```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
+```
+
+### [.isType](index.js#L467)
+
+Returns true if `node.type` matches the given `type`. Throws a `TypeError` if `node` is not an instance of `Node`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `type` **{String}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.hasType](index.js#L509)
+
+Returns true if the given `node` has the given `type` in `node.nodes`. Throws a `TypeError` if `node` is not an instance of `Node`.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `type` **{String}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.firstOfType](index.js#L542)
+
+Returns the first node from `node.nodes` of the given `type`
+
+**Params**
+
+* `nodes` **{Array}**
+* `type` **{String}**
+* `returns` **{Object|undefined}**: Returns the first matching node or undefined.
+
+**Example**
+
+```js
+var node = new Node({
+ type: 'foo',
+ nodes: [
+ new Node({type: 'text', value: 'abc'}),
+ new Node({type: 'text', value: 'xyz'})
+ ]
+});
+
+var textNode = utils.firstOfType(node.nodes, 'text');
+console.log(textNode.value);
+//=> 'abc'
+```
+
+### [.findNode](index.js#L578)
+
+Returns the node at the specified index, or the first node of the given `type` from `node.nodes`.
+
+**Params**
+
+* `nodes` **{Array}**
+* `type` **{String|Number}**: Node type or index.
+* `returns` **{Object}**: Returns a node or undefined.
+
+**Example**
+
+```js
+var node = new Node({
+ type: 'foo',
+ nodes: [
+ new Node({type: 'text', value: 'abc'}),
+ new Node({type: 'text', value: 'xyz'})
+ ]
+});
+
+var nodeOne = utils.findNode(node.nodes, 'text');
+console.log(nodeOne.value);
+//=> 'abc'
+
+var nodeTwo = utils.findNode(node.nodes, 1);
+console.log(nodeTwo.value);
+//=> 'xyz'
+```
+
+### [.isOpen](index.js#L602)
+
+Returns true if the given node is an "*.open" node.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.isClose](index.js#L631)
+
+Returns true if the given node is a "*.close" node.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.isBlock](index.js#L662)
+
+Returns true if the given node is an "*.open" node.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+var Node = require('snapdragon-node');
+var brace = new Node({type: 'brace'});
+var open = new Node({type: 'brace.open', value: '{'});
+var inner = new Node({type: 'text', value: 'a,b,c'});
+var close = new Node({type: 'brace.close', value: '}'});
+brace.push(open);
+brace.push(inner);
+brace.push(close);
+
+console.log(utils.isBlock(brace)); // true
+```
+
+### [.hasNode](index.js#L691)
+
+Returns true if `parent.nodes` has the given `node`.
+
+**Params**
+
+* `type` **{String}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+const foo = new Node({type: 'foo'});
+const bar = new Node({type: 'bar'});
+cosole.log(util.hasNode(foo, bar)); // false
+foo.push(bar);
+cosole.log(util.hasNode(foo, bar)); // true
+```
+
+### [.hasOpen](index.js#L723)
+
+Returns true if `node.nodes` **has** an `.open` node
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.hasClose](index.js#L754)
+
+Returns true if `node.nodes` **has** a `.close` node
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.hasOpenAndClose](index.js#L789)
+
+Returns true if `node.nodes` has both `.open` and `.close` nodes
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.addType](index.js#L811)
+
+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`.
+
+**Params**
+
+* `state` **{Object}**: The `compiler.state` object or custom state object.
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Array}**: Returns the `state.inside` stack for the given type.
+
+**Example**
+
+```js
+var state = { inside: {}};
+var node = new Node({type: 'brace'});
+utils.addType(state, node);
+console.log(state.inside);
+//=> { brace: [{type: 'brace'}] }
+```
+
+### [.removeType](index.js#L851)
+
+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`.
+
+**Params**
+
+* `state` **{Object}**: The `compiler.state` object or custom state object.
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `returns` **{Array}**: Returns the `state.inside` stack for the given type.
+
+**Example**
+
+```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: [] }
+```
+
+### [.isEmpty](index.js#L880)
+
+Returns true if `node.value` is an empty string, or `node.nodes` does not contain any non-empty text nodes.
+
+**Params**
+
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `fn` **{Function}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+var node = new Node({type: 'text'});
+utils.isEmpty(node); //=> true
+node.value = 'foo';
+utils.isEmpty(node); //=> false
+```
+
+### [.isInsideType](index.js#L922)
+
+Returns true if the `state.inside` stack for the given type exists and has one or more nodes on it.
+
+**Params**
+
+* `state` **{Object}**
+* `type` **{String}**
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.isInside](index.js#L956)
+
+Returns true if `node` is either a child or grand-child of the given `type`, or `state.inside[type]` is a non-empty array.
+
+**Params**
+
+* `state` **{Object}**: Either the `compiler.state` object, if it exists, or a user-supplied state object.
+* `node` **{Object}**: Instance of [snapdragon-node](https://github.com/jonschlinkert/snapdragon-node)
+* `type` **{String}**: The `node.type` to check for.
+* `returns` **{Boolean}**
+
+**Example**
+
+```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
+```
+
+### [.last](index.js#L1004)
+
+Get the last `n` element from the given `array`. Used for getting
+a node from `node.nodes.`
+
+**Params**
+
+* `array` **{Array}**
+* `n` **{Number}**
+* `returns` **{undefined}**
+
+### [.arrayify](index.js#L1028)
+
+Cast the given `value` to an array.
+
+**Params**
+
+* `value` **{any}**
+* `returns` **{Array}**
+
+**Example**
+
+```js
+console.log(utils.arrayify(''));
+//=> []
+console.log(utils.arrayify('foo'));
+//=> ['foo']
+console.log(utils.arrayify(['foo']));
+//=> ['foo']
+```
+
+### [.stringify](index.js#L1047)
+
+Convert the given `value` to a string by joining with `,`. Useful
+for creating a cheerio/CSS/DOM-style selector from a list of strings.
+
+**Params**
+
+* `value` **{any}**
+* `returns` **{Array}**
+
+### [.trim](index.js#L1060)
+
+Ensure that the given value is a string and call `.trim()` on it,
+or return an empty string.
+
+**Params**
+
+* `str` **{String}**
+* `returns` **{String}**
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [snapdragon-node](https://www.npmjs.com/package/snapdragon-node): Snapdragon utility for creating a new AST node in custom code, such as plugins. | [homepage](https://github.com/jonschlinkert/snapdragon-node "Snapdragon utility for creating a new AST node in custom code, such as plugins.")
+* [snapdragon-position](https://www.npmjs.com/package/snapdragon-position): Snapdragon util and plugin for patching the position on an AST node. | [homepage](https://github.com/here-be/snapdragon-position "Snapdragon util and plugin for patching the position on an AST node.")
+* [snapdragon-token](https://www.npmjs.com/package/snapdragon-token): Create a snapdragon token. Used by the snapdragon lexer, but can also be used by… [more](https://github.com/here-be/snapdragon-token) | [homepage](https://github.com/here-be/snapdragon-token "Create a snapdragon token. Used by the snapdragon lexer, but can also be used by plugins.")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 43 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 2 | [realityking](https://github.com/realityking) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [linkedin/in/jonschlinkert](https://linkedin.com/in/jonschlinkert)
+* [github/jonschlinkert](https://github.com/jonschlinkert)
+* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on January 11, 2018._
\ No newline at end of file
diff --git a/debian/node_modules/snapdragon-util/index.js b/debian/node_modules/snapdragon-util/index.js
new file mode 100644
index 0000000..2a23fd7
--- /dev/null
+++ b/debian/node_modules/snapdragon-util/index.js
@@ -0,0 +1,1117 @@
+'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);
+};
+
+/**
+ * Returns `node.value` or `node.val`.
+ *
+ * ```js
+ * const star = new Node({type: 'star', value: '*'});
+ * const slash = new Node({type: 'slash', val: '/'});
+ * console.log(utils.value(star)) //=> '*'
+ * console.log(utils.value(slash)) //=> '/'
+ * ```
+ * @param {Object} `node` Instance of [snapdragon-node][]
+ * @returns {String} returns
+ * @api public
+ */
+
+utils.value = function(node) {
+ if (typeof node.value === 'string') {
+ return node.value;
+ }
+ return node.val;
+};
+
+/**
+ * Append `node.value` to `compiler.output`.
+ *
+ * ```js
+ * snapdragon.compiler.set('text', utils.identity);
+ * ```
+ * @param {Object} `node` Instance of [snapdragon-node][]
+ * @returns {undefined}
+ * @api public
+ */
+
+utils.identity = function(node) {
+ append(this, utils.value(node), node);
+};
+
+/**
+ * Previously named `.emit`, this method appends the given `value`
+ * to `compiler.output` for the given node. Useful when you know
+ * what value should be appended advance, regardless of the actual
+ * value of `node.value`.
+ *
+ * ```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(value) {
+ return function(node) {
+ append(this, value, 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.value = '';
+ }
+};
+
+/**
+ * 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(isFunction(fn), 'expected a visitor function');
+ expect(node, 'node');
+ 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(isFunction(fn), 'expected a visitor function');
+ expect(node, 'node');
+ assert(isArray(node.nodes), 'expected node.nodes to be an array');
+
+ 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', value: '' };
+ *
+ * // 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, value, filter) {
+ expect(node, 'node');
+ assert(isFunction(Node), 'expected Node to be a constructor function');
+
+ if (typeof value === 'function') {
+ filter = value;
+ value = '';
+ }
+
+ if (typeof filter === 'function' && !filter(node)) return;
+ var open = new Node({ type: node.type + '.open', value: value});
+ 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', value: '' };
+ *
+ * // 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, value, filter) {
+ assert(isFunction(Node), 'expected Node to be a constructor function');
+ expect(node, 'node', Node);
+
+ if (typeof value === 'function') {
+ filter = value;
+ value = '';
+ }
+
+ if (typeof filter === 'function' && !filter(node)) return;
+ var close = new Node({ type: node.type + '.close', value: value});
+ 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');
+ if (!node) return;
+
+ if (typeof parent.push === 'function') {
+ return parent.push(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');
+ if (!node) return;
+
+ if (typeof parent.unshift === 'function') {
+ return parent.unshift(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 to be an instance of Node');
+ if (!parent.nodes) return;
+ if (!node) return;
+
+ 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) {
+ if (!utils.isNode(node)) return false;
+ switch (typeOf(type)) {
+ case 'string':
+ return node.type === type;
+ case 'regexp':
+ return type.test(node.type);
+ case 'array':
+ for (const key of type.slice()) {
+ if (utils.isType(node, key)) {
+ return true;
+ }
+ }
+ return false;
+ 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) {
+ if (!utils.isNode(node)) return false;
+ if (!Array.isArray(node.nodes)) return false;
+ for (const child of node.nodes) {
+ if (utils.isType(child, 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', value: 'abc'}),
+ * new Node({type: 'text', value: 'xyz'})
+ * ]
+ * });
+ *
+ * var textNode = utils.firstOfType(node.nodes, 'text');
+ * console.log(textNode.value);
+ * //=> '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 (const node of nodes) {
+ 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', value: 'abc'}),
+ * new Node({type: 'text', value: 'xyz'})
+ * ]
+ * });
+ *
+ * var nodeOne = utils.findNode(node.nodes, 'text');
+ * console.log(nodeOne.value);
+ * //=> 'abc'
+ *
+ * var nodeTwo = utils.findNode(node.nodes, 1);
+ * console.log(nodeTwo.value);
+ * //=> '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) {
+ if (!node) return false;
+ if (node.parent && typeof node.parent.isOpen === 'function') {
+ return node.parent.isOpen(node);
+ }
+ if (node && typeof node.isOpen === 'function') {
+ return node.isOpen(node);
+ }
+ return node.type ? node.type.slice(-5) === '.open' : false;
+};
+
+/**
+ * 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) {
+ if (!node) return false;
+ if (node.parent && typeof node.parent.isClose === 'function') {
+ return node.parent.isClose(node);
+ }
+ if (node && typeof node.isClose === 'function') {
+ return node.isClose(node);
+ }
+ return node.type ? node.type.slice(-6) === '.close' : false;
+};
+
+/**
+ * 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', value: '{'});
+ * var inner = new Node({type: 'text', value: 'a,b,c'});
+ * var close = new Node({type: 'brace.close', value: '}'});
+ * brace.push(open);
+ * brace.push(inner);
+ * brace.push(close);
+ *
+ * console.log(utils.isBlock(brace)); // true
+ * ```
+ * @param {Object} `node` Instance of [snapdragon-node][]
+ * @return {Boolean}
+ * @api public
+ */
+
+utils.isBlock = function(node) {
+ if (!node || !utils.isNode(node)) return false;
+ if (!Array.isArray(node.nodes)) {
+ return false;
+ }
+ if (node.parent && typeof node.parent.isBlock === 'function') {
+ return node.parent.isBlock(node);
+ }
+ if (typeof node.isBlock === 'function') {
+ return node.isBlock(node);
+ }
+ return utils.hasOpenAndClose(node);
+};
+
+/**
+ * Returns true if `parent.nodes` has the given `node`.
+ *
+ * ```js
+ * const foo = new Node({type: 'foo'});
+ * const bar = new Node({type: 'bar'});
+ * cosole.log(util.hasNode(foo, bar)); // false
+ * foo.push(bar);
+ * cosole.log(util.hasNode(foo, bar)); // true
+ * ```
+ * @param {String} `type`
+ * @return {Boolean}
+ * @api public
+ */
+
+utils.hasNode = function(node, child) {
+ if (!utils.isNode(node)) return false;
+ if (typeof node.has === 'function') {
+ return node.has(child);
+ }
+ if (node.nodes) {
+ return node.nodes.indexOf(child) !== -1;
+ }
+ return false;
+};
+
+/**
+ * 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 false;
+ if (node.isOpen === 'function') {
+ return node.isOpen(first);
+ }
+ return first.type === node.type + '.open';
+};
+
+/**
+ * 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 false;
+ if (typeof node.isClose === 'function') {
+ return node.isClose(last);
+ }
+ return last.type === node.type + '.close';
+};
+
+/**
+ * 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.value` 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.value = '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 (typeof fn === 'function') {
+ return fn(node);
+ }
+ return !utils.value(node);
+ }
+
+ if (node.nodes.length === 0) {
+ return true;
+ }
+
+ for (const child of node.nodes) {
+ 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 value = state.inside[key];
+
+ if (Array.isArray(value) && value.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 Array.isArray(arr) ? arr[arr.length - (n || 1)] : null;
+};
+
+utils.lastNode = function(node) {
+ return Array.isArray(node.nodes) ? utils.last(node.nodes) : null;
+};
+
+/**
+ * Cast the given `value` to an array.
+ *
+ * ```js
+ * console.log(utils.arrayify(''));
+ * //=> []
+ * console.log(utils.arrayify('foo'));
+ * //=> ['foo']
+ * console.log(utils.arrayify(['foo']));
+ * //=> ['foo']
+ * ```
+ * @param {any} `value`
+ * @return {Array}
+ * @api public
+ */
+
+utils.arrayify = function(value) {
+ if (typeof value === 'string' && value !== '') {
+ return [value];
+ }
+ if (!Array.isArray(value)) {
+ return [];
+ }
+ return value;
+};
+
+/**
+ * Convert the given `value` to a string by joining with `,`. Useful
+ * for creating a cheerio/CSS/DOM-style selector from a list of strings.
+ *
+ * @param {any} `value`
+ * @return {Array}
+ * @api public
+ */
+
+utils.stringify = function(value) {
+ return utils.arrayify(value).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 value is an object
+ */
+
+function isObject(value) {
+ return typeOf(value) === 'object';
+}
+
+/**
+ * Return true if value is a string
+ */
+
+function isString(value) {
+ return typeof value === 'string';
+}
+
+/**
+ * Return true if value is a function
+ */
+
+function isFunction(value) {
+ return typeof value === 'function';
+}
+
+/**
+ * Return true if value is an array
+ */
+
+function isArray(value) {
+ return Array.isArray(value);
+}
+
+/**
+ * Shim to ensure the `.append` methods work with any version of snapdragon
+ */
+
+function append(compiler, value, node) {
+ if (typeof compiler.append !== 'function') {
+ return compiler.emit(value, node);
+ }
+ return compiler.append(value, node);
+}
+
+/**
+ * Simplified assertion. Throws an error is `value` is falsey.
+ */
+
+function assert(value, message) {
+ if (!value) throw new Error(message);
+}
+function expect(node, name, Node) {
+ const isNode = (Node && Node.isNode) ? Node.isNode : utils.isNode;
+ assert(isNode(node), `expected ${name} to be an instance of Node`);
+}
diff --git a/debian/node_modules/snapdragon-util/package.json b/debian/node_modules/snapdragon-util/package.json
new file mode 100644
index 0000000..51b3d28
--- /dev/null
+++ b/debian/node_modules/snapdragon-util/package.json
@@ -0,0 +1,74 @@
+{
+ "name": "snapdragon-util",
+ "description": "Utilities for the snapdragon parser/compiler.",
+ "version": "5.0.1",
+ "homepage": "https://github.com/here-be/snapdragon-util",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "contributors": [
+ "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+ "Rouven Weßling (www.rouvenwessling.de)"
+ ],
+ "repository": "here-be/snapdragon-util",
+ "bugs": {
+ "url": "https://github.com/here-be/snapdragon-util/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=6"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "dependencies": {
+ "kind-of": "^6.0.2"
+ },
+ "devDependencies": {
+ "define-property": "^2.0.0",
+ "gulp": "^3.9.1",
+ "gulp-eslint": "^4.0.1",
+ "gulp-format-md": "^1.0.0",
+ "gulp-istanbul": "^1.1.3",
+ "gulp-mocha": "^5.0.0",
+ "isobject": "^3.0.1",
+ "mocha": "^3.5.3",
+ "snapdragon": "^0.11.0"
+ },
+ "keywords": [
+ "capture",
+ "compile",
+ "compiler",
+ "convert",
+ "match",
+ "parse",
+ "parser",
+ "plugin",
+ "render",
+ "snapdragon",
+ "snapdragonplugin",
+ "transform",
+ "util"
+ ],
+ "verb": {
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "related": {
+ "list": [
+ "snapdragon-node",
+ "snapdragon-position",
+ "snapdragon-token"
+ ]
+ },
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ }
+ }
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/node-snapdragon.git
More information about the Pkg-javascript-commits
mailing list