",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ },
+ "license": "MIT",
+ "main": "index.js",
+ "scripts": {
+ "prepublishOnly": "safe-publish-latest",
+ "prepublish": "not-in-publish || npm run prepublishOnly",
+ "pretest": "npm run lint",
+ "test": "npm run tests-only && npm run test:harmony",
+ "tests-only": "nyc node test",
+ "test:harmony": "nyc node --harmony --es-staging test",
+ "test:corejs": "nyc tape test-corejs.js",
+ "posttest": "npx aud --production",
+ "lint": "eslint .",
+ "eccheck": "eclint check *.js **/*.js > /dev/null",
+ "version": "auto-changelog && git add CHANGELOG.md",
+ "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/inspect-js/is-regex.git"
+ },
+ "bugs": {
+ "url": "https://github.com/inspect-js/is-regex/issues"
+ },
+ "homepage": "https://github.com/inspect-js/is-regex",
+ "keywords": [
+ "regex",
+ "regexp",
+ "is",
+ "regular expression",
+ "regular",
+ "expression"
+ ],
+ "dependencies": {
+ "call-bind": "^1.0.2",
+ "has-tostringtag": "^1.0.0"
+ },
+ "devDependencies": {
+ "@ljharb/eslint-config": "^17.6.0",
+ "aud": "^1.1.5",
+ "auto-changelog": "^2.3.0",
+ "core-js": "^3.16.0",
+ "eclint": "^2.8.1",
+ "eslint": "^7.32.0",
+ "foreach": "^2.0.5",
+ "nyc": "^10.3.2",
+ "safe-publish-latest": "^1.1.4",
+ "tape": "^5.3.0"
+ },
+ "testling": {
+ "files": "test/index.js",
+ "browsers": [
+ "iexplore/6.0..latest",
+ "firefox/3.0..6.0",
+ "firefox/15.0..latest",
+ "firefox/nightly",
+ "chrome/4.0..10.0",
+ "chrome/20.0..latest",
+ "chrome/canary",
+ "opera/10.0..latest",
+ "opera/next",
+ "safari/4.0..latest",
+ "ipad/6.0..latest",
+ "iphone/6.0..latest",
+ "android-browser/4.2"
+ ]
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "auto-changelog": {
+ "output": "CHANGELOG.md",
+ "template": "keepachangelog",
+ "unreleased": false,
+ "commitLimit": false,
+ "backfillLimit": false,
+ "hideCredit": true
+ }
+}
diff --git a/node_modules/is-regex/test/index.js b/node_modules/is-regex/test/index.js
new file mode 100644
index 0000000..f6c0802
--- /dev/null
+++ b/node_modules/is-regex/test/index.js
@@ -0,0 +1,104 @@
+'use strict';
+
+var hasToStringTag = require('has-tostringtag/shams')();
+var forEach = require('foreach');
+var test = require('tape');
+var isRegex = require('..');
+
+test('not regexes', function (t) {
+ t.notOk(isRegex(), 'undefined is not regex');
+ t.notOk(isRegex(null), 'null is not regex');
+ t.notOk(isRegex(false), 'false is not regex');
+ t.notOk(isRegex(true), 'true is not regex');
+ t.notOk(isRegex(42), 'number is not regex');
+ t.notOk(isRegex('foo'), 'string is not regex');
+ t.notOk(isRegex([]), 'array is not regex');
+ t.notOk(isRegex({}), 'object is not regex');
+ t.notOk(isRegex(function () {}), 'function is not regex');
+ t.end();
+});
+
+test('@@toStringTag', { skip: !hasToStringTag }, function (t) {
+ var regex = /a/g;
+ var fakeRegex = {
+ toString: function () { return String(regex); },
+ valueOf: function () { return regex; }
+ };
+ fakeRegex[Symbol.toStringTag] = 'RegExp';
+ t.notOk(isRegex(fakeRegex), 'fake RegExp with @@toStringTag "RegExp" is not regex');
+ t.end();
+});
+
+test('regexes', function (t) {
+ t.ok(isRegex(/a/g), 'regex literal is regex');
+ t.ok(isRegex(new RegExp('a', 'g')), 'regex object is regex');
+ t.end();
+});
+
+test('does not mutate regexes', function (t) {
+ t.test('lastIndex is a marker object', function (st) {
+ var regex = /a/;
+ var marker = {};
+ regex.lastIndex = marker;
+ st.equal(regex.lastIndex, marker, 'lastIndex is the marker object');
+ st.ok(isRegex(regex), 'is regex');
+ st.equal(regex.lastIndex, marker, 'lastIndex is the marker object after isRegex');
+ st.end();
+ });
+
+ t.test('lastIndex is nonzero', function (st) {
+ var regex = /a/;
+ regex.lastIndex = 3;
+ st.equal(regex.lastIndex, 3, 'lastIndex is 3');
+ st.ok(isRegex(regex), 'is regex');
+ st.equal(regex.lastIndex, 3, 'lastIndex is 3 after isRegex');
+ st.end();
+ });
+
+ t.end();
+});
+
+test('does not perform operations observable to Proxies', { skip: typeof Proxy !== 'function' }, function (t) {
+ var Handler = function () {
+ this.trapCalls = [];
+ };
+
+ forEach([
+ 'defineProperty',
+ 'deleteProperty',
+ 'get',
+ 'getOwnPropertyDescriptor',
+ 'getPrototypeOf',
+ 'has',
+ 'isExtensible',
+ 'ownKeys',
+ 'preventExtensions',
+ 'set',
+ 'setPrototypeOf'
+ ], function (trapName) {
+ Handler.prototype[trapName] = function () {
+ this.trapCalls.push(trapName);
+ return Reflect[trapName].apply(Reflect, arguments);
+ };
+ });
+
+ t.test('proxy of object', function (st) {
+ var handler = new Handler();
+ var proxy = new Proxy({ lastIndex: 0 }, handler);
+
+ st.equal(isRegex(proxy), false, 'proxy of plain object is not regex');
+ st.deepEqual(handler.trapCalls, ['getOwnPropertyDescriptor'], 'no unexpected proxy traps were triggered');
+ st.end();
+ });
+
+ t.test('proxy of RegExp instance', function (st) {
+ var handler = new Handler();
+ var proxy = new Proxy(/a/, handler);
+
+ st.equal(isRegex(proxy), false, 'proxy of RegExp instance is not regex');
+ st.deepEqual(handler.trapCalls, ['getOwnPropertyDescriptor'], 'no unexpected proxy traps were triggered');
+ st.end();
+ });
+
+ t.end();
+});
diff --git a/node_modules/js-stringify/.npmignore b/node_modules/js-stringify/.npmignore
new file mode 100644
index 0000000..b83202d
--- /dev/null
+++ b/node_modules/js-stringify/.npmignore
@@ -0,0 +1,13 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+pids
+logs
+results
+npm-debug.log
+node_modules
diff --git a/node_modules/js-stringify/.travis.yml b/node_modules/js-stringify/.travis.yml
new file mode 100644
index 0000000..6e5919d
--- /dev/null
+++ b/node_modules/js-stringify/.travis.yml
@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+ - "0.10"
diff --git a/node_modules/js-stringify/LICENSE b/node_modules/js-stringify/LICENSE
new file mode 100644
index 0000000..27cc9f3
--- /dev/null
+++ b/node_modules/js-stringify/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Forbes Lindesay
+
+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.
\ No newline at end of file
diff --git a/node_modules/js-stringify/README.md b/node_modules/js-stringify/README.md
new file mode 100644
index 0000000..657333f
--- /dev/null
+++ b/node_modules/js-stringify/README.md
@@ -0,0 +1,34 @@
+# js-stringify
+
+Stringify an object so it can be safely inlined in JavaScript code
+
+[](https://travis-ci.org/jadejs/js-stringify)
+[](https://gemnasium.com/jadejs/js-stringify)
+[](https://www.npmjs.org/package/js-stringify)
+
+## Installation
+
+ npm install js-stringify
+
+## Usage
+
+```js
+
+var assert = require('assert');
+var stringify = require('js-stringify');
+
+assert(stringify('foo') === '"foo"');
+assert(stringify('foo\u2028bar\u2029baz') === '"foo\\u2028bar\\u2029baz"');
+assert(stringify(new Date('2014-12-19T03:42:00.000Z')) === 'new Date("2014-12-19T03:42:00.000Z")');
+assert(stringify({foo: 'bar'}) === '{"foo":"bar"}');
+assert(stringify(undefined) === 'undefined');
+assert(stringify(null) === 'null');
+assert(
+ stringify({val: ""}) ===
+ '{"val":"\\u003C\\u002Fscript\\u003E\\u003Cscript\\u003Ealert(\'bad actor\')\\u003C\\u002Fscript\\u003E"}'
+);
+```
+
+## License
+
+ MIT
diff --git a/node_modules/js-stringify/index.js b/node_modules/js-stringify/index.js
new file mode 100644
index 0000000..8febfc4
--- /dev/null
+++ b/node_modules/js-stringify/index.js
@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = stringify;
+function stringify(obj) {
+ if (obj instanceof Date) {
+ return 'new Date(' + stringify(obj.toISOString()) + ')';
+ }
+ if (obj === undefined) {
+ return 'undefined';
+ }
+ return JSON.stringify(obj)
+ .replace(/\u2028/g, '\\u2028')
+ .replace(/\u2029/g, '\\u2029')
+ .replace(//g, '\\u003E')
+ .replace(/\//g, '\\u002F');
+}
diff --git a/node_modules/js-stringify/package.json b/node_modules/js-stringify/package.json
new file mode 100644
index 0000000..c5f1c17
--- /dev/null
+++ b/node_modules/js-stringify/package.json
@@ -0,0 +1,17 @@
+{
+ "name": "js-stringify",
+ "version": "1.0.2",
+ "description": "Stringify an object so it can be safely inlined in JavaScript code",
+ "keywords": [],
+ "dependencies": {},
+ "devDependencies": {},
+ "scripts": {
+ "test": "node test"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/jadejs/js-stringify.git"
+ },
+ "author": "ForbesLindesay",
+ "license": "MIT"
+}
\ No newline at end of file
diff --git a/node_modules/js-stringify/test/index.js b/node_modules/js-stringify/test/index.js
new file mode 100644
index 0000000..9a84a98
--- /dev/null
+++ b/node_modules/js-stringify/test/index.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var assert = require('assert');
+var stringify = require('../');
+
+assert(stringify('foo') === '"foo"');
+assert(stringify('foo\u2028bar\u2029baz') === '"foo\\u2028bar\\u2029baz"');
+assert(stringify(new Date('2014-12-19T03:42:00.000Z')) === 'new Date("2014-12-19T03:42:00.000Z")');
+assert(stringify({foo: 'bar'}) === '{"foo":"bar"}');
+assert(stringify(undefined) === 'undefined');
+assert(stringify(null) === 'null');
+assert(
+ stringify({val: ""}) ===
+ '{"val":"\\u003C\\u002Fscript\\u003E\\u003Cscript\\u003Ealert(\'bad actor\')\\u003C\\u002Fscript\\u003E"}'
+);
+
+console.log('tests passed');
diff --git a/node_modules/jstransformer/CHANGELOG.md b/node_modules/jstransformer/CHANGELOG.md
new file mode 100644
index 0000000..f4655b0
--- /dev/null
+++ b/node_modules/jstransformer/CHANGELOG.md
@@ -0,0 +1,38 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [1.0.0] - 2016-06-06
+### Changed
+- Browser support is fixed
+- Marked as stable
+
+## [0.0.4] - 2015-11-23
+### Changed
+- Switched to [Keep a Changelog](http://keepachangelog.com/) spec for CHANGELOG.md
+- Creates an `options.filename` for `*File()` functions, if one is not provided
+
+## [0.0.3] - 2015-07-13
+### Added
+- Added `.render()` fallbacks for `.compile()`
+
+### Changed
+- Prefers locals over options when passing a single argument to `.render()`
+- Updated dependencies
+
+## [0.0.2] - 2015-04-11
+### Added
+- Now have a logo
+- Added tests
+
+### Changed
+- Updated documentation
+
+## 0.0.1 - 2015-02-09
+### Added
+- Initial release
+
+[1.0.0]: https://github.com/jstransformers/jstransformer/compare/0.0.4...1.0.0
+[0.0.4]: https://github.com/jstransformers/jstransformer/compare/0.0.3...0.0.4
+[0.0.3]: https://github.com/jstransformers/jstransformer/compare/0.0.2...0.0.3
+[0.0.2]: https://github.com/jstransformers/jstransformer/compare/0.0.1...0.0.2
diff --git a/node_modules/jstransformer/LICENSE.md b/node_modules/jstransformer/LICENSE.md
new file mode 100644
index 0000000..006e201
--- /dev/null
+++ b/node_modules/jstransformer/LICENSE.md
@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) 2015 Forbes Lindesay
+
+> 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/node_modules/jstransformer/README.md b/node_modules/jstransformer/README.md
new file mode 100644
index 0000000..99dca54
--- /dev/null
+++ b/node_modules/jstransformer/README.md
@@ -0,0 +1,114 @@
+
+JSTransformer
+Normalize the API of any jstransformer
+
+
+
+
+
+
+
+## Installation
+
+ npm install jstransformer
+
+## Usage
+
+```js
+var transformer = require('jstransformer');
+var marked = transformer(require('jstransformer-marked'));
+
+var options = {};
+var res = marked.render('Some **markdown**', options);
+// => {body: 'Some markdown', dependencies: []}
+```
+
+This gives the same API regardless of the jstransformer passed in.
+
+## API
+
+A transformer, once normalised using this module, will implement the following methods. Note that if the underlying transformer cannot be used to implement the functionality, it may ultimately just throw an error.
+
+### Returned object from `.render*`
+
+```js
+{body: String, dependencies: Array.}
+```
+
+ - `body` represents the result as a string
+ - `dependencies` is an array of files that were read in as part of the render process (or an empty array if there were no dependencies)
+
+### `.render`
+
+```js
+transformer.render(str, options, locals);
+=> {body: String, dependencies: Array.}
+```
+
+_requires the underlying transform to implement `.render` or `.compile`_
+
+Transform a string and return an object.
+
+### `.renderAsync`
+
+```js
+transformer.renderAsync(str[, options], locals, callback);
+```
+
+```js
+transformer.renderAsync(str[, options], locals);
+=> Promise({body: String, dependencies: Array.})
+```
+
+_requires the underlying transform to implement `.renderAsync` or `.render`_
+
+Transform a string asynchronously. If a callback is provided, it is called as `callback(err, data)`, otherwise a Promise is returned.
+
+### `.renderFile`
+
+```js
+transformer.renderFile(filename, options, locals)
+=> {body: String, dependencies: Array.}
+```
+
+_requires the underlying transform to implement `.renderFile`, `.render`, `.compileFile`, or `.compile`_
+
+Transform a file and return an object.
+
+### `.renderFileAsync`
+
+```js
+transformer.renderFileAsync(filename[, options], locals, callback);
+```
+
+```js
+transformer.renderFileAsync(filename[, options], locals);
+=> Promise({body: String, dependencies: Array.})
+```
+
+_requires the underlying transform to implement `.renderFileAsync`, `.renderFile`, `.renderAsync`, `.render`, `.compileFileAsync`, `.compileFile`, `.compileAsync`, or `.compileFile`_
+
+Transform a file asynchronously. If a callback is provided, it is called as `callback(err, data)`, otherwise a Promise is returned.
+
+### `.inputFormats`
+
+```js
+var formats = transformer.inputFormats;
+=> ['md', 'markdown']
+```
+
+Returns an array of strings representing potential input formats for the transform. If not provided directly by the transform, results in an array containing the name of the transform.
+
+### `.outputFormat`
+
+```js
+var md = require('jstransformer')(require('jstransformer-markdown'))
+var outputFormat = md.outputFormat
+=> 'html'
+```
+
+Returns a string representing the default output format the transform would be expected to return when calling `.render()`.
+
+## License
+
+MIT
diff --git a/node_modules/jstransformer/index.js b/node_modules/jstransformer/index.js
new file mode 100644
index 0000000..c12d7f9
--- /dev/null
+++ b/node_modules/jstransformer/index.js
@@ -0,0 +1,359 @@
+'use strict';
+
+var fs = require('fs');
+var assert = require('assert');
+var Promise = require('promise');
+var isPromise = require('is-promise');
+
+var tr = (module.exports = function (transformer) {
+ return new Transformer(transformer);
+});
+tr.Transformer = Transformer;
+tr.normalizeFn = normalizeFn;
+tr.normalizeFnAsync = normalizeFnAsync;
+tr.normalize = normalize;
+tr.normalizeAsync = normalizeAsync;
+if (fs.readFile) {
+ tr.readFile = Promise.denodeify(fs.readFile);
+ tr.readFileSync = fs.readFileSync;
+} else {
+ tr.readFile = function () { throw new Error('fs.readFile unsupported'); };
+ tr.readFileSync = function () { throw new Error('fs.readFileSync unsupported'); };
+}
+
+function normalizeFn(result) {
+ if (typeof result === 'function') {
+ return {fn: result, dependencies: []};
+ } else if (result && typeof result === 'object' && typeof result.fn === 'function') {
+ if ('dependencies' in result) {
+ if (!Array.isArray(result.dependencies)) {
+ throw new Error('Result should have a dependencies property that is an array');
+ }
+ } else {
+ result.dependencies = [];
+ }
+ return result;
+ } else {
+ throw new Error('Invalid result object from transform.');
+ }
+}
+function normalizeFnAsync(result, cb) {
+ return Promise.resolve(result).then(function (result) {
+ if (result && isPromise(result.fn)) {
+ return result.fn.then(function (fn) {
+ result.fn = fn;
+ return result;
+ });
+ }
+ return result;
+ }).then(tr.normalizeFn).nodeify(cb);
+}
+function normalize(result) {
+ if (typeof result === 'string') {
+ return {body: result, dependencies: []};
+ } else if (result && typeof result === 'object' && typeof result.body === 'string') {
+ if ('dependencies' in result) {
+ if (!Array.isArray(result.dependencies)) {
+ throw new Error('Result should have a dependencies property that is an array');
+ }
+ } else {
+ result.dependencies = [];
+ }
+ return result;
+ } else {
+ throw new Error('Invalid result object from transform.');
+ }
+}
+function normalizeAsync(result, cb) {
+ return Promise.resolve(result).then(function (result) {
+ if (result && isPromise(result.body)) {
+ return result.body.then(function (body) {
+ result.body = body;
+ return result;
+ });
+ }
+ return result;
+ }).then(tr.normalize).nodeify(cb);
+}
+
+function Transformer(tr) {
+ assert(tr, 'Transformer must be an object');
+ assert(typeof tr.name === 'string', 'Transformer must have a name');
+ assert(typeof tr.outputFormat === 'string', 'Transformer must have an output format');
+ assert([
+ 'compile',
+ 'compileAsync',
+ 'compileFile',
+ 'compileFileAsync',
+ 'compileClient',
+ 'compileClientAsync',
+ 'compileFileClient',
+ 'compileFileClientAsync',
+ 'render',
+ 'renderAsync',
+ 'renderFile',
+ 'renderFileAsync'
+ ].some(function (method) {
+ return typeof tr[method] === 'function';
+ }), 'Transformer must implement at least one of the potential methods.');
+ this._tr = tr;
+ this.name = this._tr.name;
+ this.outputFormat = this._tr.outputFormat;
+ this.inputFormats = this._tr.inputFormats || [this.name];
+}
+
+var fallbacks = {
+ compile: ['compile', 'render'],
+ compileAsync: ['compileAsync', 'compile', 'render'],
+ compileFile: ['compileFile', 'compile', 'renderFile', 'render'],
+ compileFileAsync: [
+ 'compileFileAsync', 'compileFile', 'compileAsync', 'compile',
+ 'renderFile', 'render'
+ ],
+ compileClient: ['compileClient'],
+ compileClientAsync: ['compileClientAsync', 'compileClient'],
+ compileFileClient: ['compileFileClient', 'compileClient'],
+ compileFileClientAsync: [
+ 'compileFileClientAsync', 'compileFileClient', 'compileClientAsync', 'compileClient'
+ ],
+ render: ['render', 'compile'],
+ renderAsync: ['renderAsync', 'render', 'compileAsync', 'compile'],
+ renderFile: ['renderFile', 'render', 'compileFile', 'compile'],
+ renderFileAsync: [
+ 'renderFileAsync', 'renderFile', 'renderAsync', 'render',
+ 'compileFileAsync', 'compileFile', 'compileAsync', 'compile'
+ ]
+};
+
+Transformer.prototype._hasMethod = function (method) {
+ return typeof this._tr[method] === 'function';
+};
+Transformer.prototype.can = function (method) {
+ return fallbacks[method].some(function (method) {
+ return this._hasMethod(method);
+ }.bind(this));
+};
+
+/* COMPILE */
+
+Transformer.prototype.compile = function (str, options) {
+ if (!this._hasMethod('compile')) {
+ if (this.can('render')) {
+ var _this = this;
+ return {
+ fn: function (locals) {
+ return tr.normalize(_this._tr.render(str, options, locals)).body;
+ },
+ dependencies: []
+ };
+ }
+ if (this.can('compileAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support synchronous compilation');
+ } else if (this.can('compileFileAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support compiling plain strings');
+ } else {
+ throw new Error('The Transform "' + this.name + '" does not support compilation');
+ }
+ }
+ return tr.normalizeFn(this._tr.compile(str, options));
+};
+Transformer.prototype.compileAsync = function (str, options, cb) {
+ if (!this.can('compileAsync')) { // compileFile* || renderFile* || renderAsync || compile*Client*
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling plain strings')).nodeify(cb);
+ }
+ if (this._hasMethod('compileAsync')) {
+ return tr.normalizeFnAsync(this._tr.compileAsync(str, options), cb);
+ } else { // render || compile
+ return tr.normalizeFnAsync(this.compile(str, options), cb);
+ }
+};
+Transformer.prototype.compileFile = function (filename, options) {
+ if (!this.can('compileFile')) { // compile*Client* || compile*Async || render*Async
+ throw new Error('The Transform "' + this.name + '" does not support synchronous compilation');
+ }
+ if (this._hasMethod('compileFile')) {
+ return tr.normalizeFn(this._tr.compileFile(filename, options));
+ } else if (this._hasMethod('renderFile')) {
+ return tr.normalizeFn(function (locals) {
+ return tr.normalize(this._tr.renderFile(filename, options, locals)).body;
+ }.bind(this));
+ } else { // render || compile
+ if (!options) options = {};
+ if (options.filename === undefined) options.filename = filename;
+ return this.compile(tr.readFileSync(filename, 'utf8'), options);
+ }
+};
+Transformer.prototype.compileFileAsync = function (filename, options, cb) {
+ if (!this.can('compileFileAsync')) {
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support compilation'));
+ }
+ if (this._hasMethod('compileFileAsync')) {
+ return tr.normalizeFnAsync(this._tr.compileFileAsync(filename, options), cb);
+ } else if (this._hasMethod('compileFile') || this._hasMethod('renderFile')) {
+ return tr.normalizeFnAsync(this.compileFile(filename, options), cb);
+ } else { // compileAsync || compile || render
+ if (!options) options = {};
+ if (options.filename === undefined) options.filename = filename;
+ return tr.normalizeFnAsync(tr.readFile(filename, 'utf8').then(function (str) {
+ if (this._hasMethod('compileAsync')) {
+ return this._tr.compileAsync(str, options);
+ } else { // compile || render
+ return this.compile(str, options);
+ }
+ }.bind(this)), cb);
+ }
+};
+
+/* COMPILE CLIENT */
+
+
+Transformer.prototype.compileClient = function (str, options) {
+ if (!this.can('compileClient')) {
+ if (this.can('compileClientAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support compiling for the client synchronously.');
+ } else if (this.can('compileFileClientAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support compiling for the client from a string.');
+ } else {
+ throw new Error('The Transform "' + this.name + '" does not support compiling for the client');
+ }
+ }
+ return tr.normalize(this._tr.compileClient(str, options));
+};
+Transformer.prototype.compileClientAsync = function (str, options, cb) {
+ if (!this.can('compileClientAsync')) {
+ if (this.can('compileFileClientAsync')) {
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling for the client from a string.')).nodeify(cb);
+ } else {
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling for the client')).nodeify(cb);
+ }
+ }
+ if (this._hasMethod('compileClientAsync')) {
+ return tr.normalizeAsync(this._tr.compileClientAsync(str, options), cb);
+ } else {
+ return tr.normalizeAsync(this._tr.compileClient(str, options), cb);
+ }
+};
+Transformer.prototype.compileFileClient = function (filename, options) {
+ if (!this.can('compileFileClient')) {
+ if (this.can('compileFileClientAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support compiling for the client synchronously.');
+ } else {
+ throw new Error('The Transform "' + this.name + '" does not support compiling for the client');
+ }
+ }
+ if (this._hasMethod('compileFileClient')) {
+ return tr.normalize(this._tr.compileFileClient(filename, options));
+ } else {
+ if (!options) options = {};
+ if (options.filename === undefined) options.filename = filename;
+ return tr.normalize(this._tr.compileClient(tr.readFileSync(filename, 'utf8'), options));
+ }
+};
+Transformer.prototype.compileFileClientAsync = function (filename, options, cb) {
+ if (!this.can('compileFileClientAsync')) {
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support compiling for the client')).nodeify(cb)
+ }
+ if (this._hasMethod('compileFileClientAsync')) {
+ return tr.normalizeAsync(this._tr.compileFileClientAsync(filename, options), cb);
+ } else if (this._hasMethod('compileFileClient')) {
+ return tr.normalizeAsync(this._tr.compileFileClient(filename, options), cb);
+ } else {
+ if (!options) options = {};
+ if (options.filename === undefined) options.filename = filename;
+ return tr.normalizeAsync(tr.readFile(filename, 'utf8').then(function (str) {
+ if (this._hasMethod('compileClientAsync')) {
+ return this._tr.compileClientAsync(str, options);
+ } else {
+ return this._tr.compileClient(str, options);
+ }
+ }.bind(this)), cb);
+ }
+};
+
+/* RENDER */
+
+Transformer.prototype.render = function (str, options, locals) {
+ if (!this.can('render')) {
+ if (this.can('renderAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support rendering synchronously.');
+ } else if (this.can('renderFileAsync')) {
+ throw new Error('The Transform "' + this.name + '" does not support rendering from a string.');
+ } else {
+ throw new Error('The Transform "' + this.name + '" does not support rendering');
+ }
+ }
+ if (this._hasMethod('render')) {
+ return tr.normalize(this._tr.render(str, options, locals));
+ } else {
+ var compiled = tr.normalizeFn(this._tr.compile(str, options));
+ var body = compiled.fn(locals || options);
+ if (typeof body !== 'string') {
+ throw new Error('The Transform "' + this.name + '" does not support rendering synchronously.');
+ }
+ return tr.normalize({body: body, dependencies: compiled.dependencies});
+ }
+};
+Transformer.prototype.renderAsync = function (str, options, locals, cb) {
+ if (typeof locals === 'function') {
+ cb = locals;
+ locals = options;
+ }
+ if (!this.can('renderAsync')) {
+ if (this.can('renderFileAsync')) {
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support rendering from a string.')).nodeify(cb);
+ } else {
+ return Promise.reject(new Error('The Transform "' + this.name + '" does not support rendering')).nodeify(cb);
+ }
+ }
+ if (this._hasMethod('renderAsync')) {
+ return tr.normalizeAsync(this._tr.renderAsync(str, options, locals), cb);
+ } else if (this._hasMethod('render')) {
+ return tr.normalizeAsync(this._tr.render(str, options, locals), cb);
+ } else {
+ return tr.normalizeAsync(this.compileAsync(str, options).then(function (compiled) {
+ return {body: compiled.fn(locals || options), dependencies: compiled.dependencies};
+ }), cb);
+ }
+};
+Transformer.prototype.renderFile = function (filename, options, locals) {
+ if (!this.can('renderFile')) { // *Async, *Client
+ throw new Error('The Transform "' + this.name + '" does not support rendering synchronously.');
+ }
+
+ if (this._hasMethod('renderFile')) {
+ return tr.normalize(this._tr.renderFile(filename, options, locals));
+ } else if (this._hasMethod('render')) {
+ if (!options) options = {};
+ if (options.filename === undefined) options.filename = filename;
+ return tr.normalize(this._tr.render(tr.readFileSync(filename, 'utf8'), options, locals));
+ } else { // compile || compileFile
+ var compiled = this.compileFile(filename, options);
+ return tr.normalize({body: compiled.fn(locals || options), dependencies: compiled.dependencies});
+ }
+};
+Transformer.prototype.renderFileAsync = function (filename, options, locals, cb) {
+ if (!this.can('renderFileAsync')) { // *Client
+ throw new Error('The Transform "' + this.name + '" does not support rendering.');
+ }
+
+ if (typeof locals === 'function') {
+ cb = locals;
+ locals = options;
+ }
+ if (this._hasMethod('renderFileAsync')) {
+ return tr.normalizeAsync(this._tr.renderFileAsync(filename, options, locals), cb);
+ } else if (this._hasMethod('renderFile')) {
+ return tr.normalizeAsync(this._tr.renderFile(filename, options, locals), cb);
+ } else if (this._hasMethod('compile') || this._hasMethod('compileAsync')
+ || this._hasMethod('compileFile') || this._hasMethod('compileFileAsync')) {
+ return tr.normalizeAsync(this.compileFileAsync(filename, options).then(function (compiled) {
+ return {body: compiled.fn(locals || options), dependencies: compiled.dependencies};
+ }), cb);
+ } else { // render || renderAsync
+ if (!options) options = {};
+ if (options.filename === undefined) options.filename = filename;
+ return tr.normalizeAsync(tr.readFile(filename, 'utf8').then(function (str) {
+ return this.renderAsync(str, options, locals);
+ }.bind(this)), cb);
+ }
+};
diff --git a/node_modules/jstransformer/package.json b/node_modules/jstransformer/package.json
new file mode 100644
index 0000000..3dce89a
--- /dev/null
+++ b/node_modules/jstransformer/package.json
@@ -0,0 +1,31 @@
+{
+ "name": "jstransformer",
+ "version": "1.0.0",
+ "description": "Normalize the API of any jstransformer",
+ "keywords": [
+ "jstransformer"
+ ],
+ "dependencies": {
+ "is-promise": "^2.0.0",
+ "promise": "^7.0.1"
+ },
+ "devDependencies": {
+ "coveralls": "^2.11.2",
+ "istanbul": "^0.4.0",
+ "testit": "^2.0.2"
+ },
+ "scripts": {
+ "test": "node test",
+ "coverage": "istanbul cover test",
+ "coveralls": "npm run coverage && cat ./coverage/lcov.info | coveralls"
+ },
+ "files": [
+ "index.js"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/jstransformers/jstransformer.git"
+ },
+ "author": "ForbesLindesay",
+ "license": "MIT"
+}
diff --git a/node_modules/merge-descriptors/README.md b/node_modules/merge-descriptors/README.md
index d593c0e..3403f4a 100644
--- a/node_modules/merge-descriptors/README.md
+++ b/node_modules/merge-descriptors/README.md
@@ -1,4 +1,4 @@
-# Merge Descriptors
+# merge-descriptors
[![NPM Version][npm-image]][npm-url]
[![NPM Downloads][downloads-image]][downloads-url]
@@ -27,12 +27,13 @@ animal.name === 'jon'
### merge(destination, source)
-Redefines `destination`'s descriptors with `source`'s.
+Redefines `destination`'s descriptors with `source`'s. The return value is the
+`destination` object.
### merge(destination, source, false)
Defines `source`'s descriptors on `destination` if `destination` does not have
-a descriptor by the same name.
+a descriptor by the same name. The return value is the `destination` object.
## License
diff --git a/node_modules/merge-descriptors/index.js b/node_modules/merge-descriptors/index.js
index 573b132..f22ebab 100644
--- a/node_modules/merge-descriptors/index.js
+++ b/node_modules/merge-descriptors/index.js
@@ -31,7 +31,7 @@ var hasOwnProperty = Object.prototype.hasOwnProperty
* @public
*/
-function merge(dest, src, redefine) {
+function merge (dest, src, redefine) {
if (!dest) {
throw new TypeError('argument dest is required')
}
@@ -45,9 +45,9 @@ function merge(dest, src, redefine) {
redefine = true
}
- Object.getOwnPropertyNames(src).forEach(function forEachOwnPropertyName(name) {
+ Object.getOwnPropertyNames(src).forEach(function forEachOwnPropertyName (name) {
if (!redefine && hasOwnProperty.call(dest, name)) {
- // Skip desriptor
+ // Skip descriptor
return
}
diff --git a/node_modules/merge-descriptors/package.json b/node_modules/merge-descriptors/package.json
index 514cdbd..aa9af0a 100644
--- a/node_modules/merge-descriptors/package.json
+++ b/node_modules/merge-descriptors/package.json
@@ -1,7 +1,7 @@
{
"name": "merge-descriptors",
"description": "Merge objects using descriptors",
- "version": "1.0.1",
+ "version": "1.0.3",
"author": {
"name": "Jonathan Ong",
"email": "me@jongleberry.com",
@@ -13,10 +13,17 @@
"Mike Grabowski "
],
"license": "MIT",
- "repository": "component/merge-descriptors",
+ "repository": "sindresorhus/merge-descriptors",
+ "funding": "https://github.com/sponsors/sindresorhus",
"devDependencies": {
- "istanbul": "0.4.1",
- "mocha": "1.21.5"
+ "eslint": "5.9.0",
+ "eslint-config-standard": "12.0.0",
+ "eslint-plugin-import": "2.14.0",
+ "eslint-plugin-node": "7.0.1",
+ "eslint-plugin-promise": "4.0.1",
+ "eslint-plugin-standard": "4.0.0",
+ "mocha": "5.2.0",
+ "nyc": "13.1.0"
},
"files": [
"HISTORY.md",
@@ -25,8 +32,8 @@
"index.js"
],
"scripts": {
- "test": "mocha --reporter spec --bail --check-leaks test/",
- "test-ci": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/",
- "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/"
+ "lint": "eslint .",
+ "test": "mocha test/",
+ "test-cov": "nyc --reporter=html --reporter=text npm test"
}
}
diff --git a/node_modules/object-assign/index.js b/node_modules/object-assign/index.js
new file mode 100644
index 0000000..0930cf8
--- /dev/null
+++ b/node_modules/object-assign/index.js
@@ -0,0 +1,90 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+'use strict';
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+ if (val === null || val === undefined) {
+ throw new TypeError('Object.assign cannot be called with null or undefined');
+ }
+
+ return Object(val);
+}
+
+function shouldUseNative() {
+ try {
+ if (!Object.assign) {
+ return false;
+ }
+
+ // Detect buggy property enumeration order in older V8 versions.
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+ var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
+ test1[5] = 'de';
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
+ return false;
+ }
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test2 = {};
+ for (var i = 0; i < 10; i++) {
+ test2['_' + String.fromCharCode(i)] = i;
+ }
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+ return test2[n];
+ });
+ if (order2.join('') !== '0123456789') {
+ return false;
+ }
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test3 = {};
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+ test3[letter] = letter;
+ });
+ if (Object.keys(Object.assign({}, test3)).join('') !==
+ 'abcdefghijklmnopqrst') {
+ return false;
+ }
+
+ return true;
+ } catch (err) {
+ // We don't expect any of the above to throw, but better to be safe.
+ return false;
+ }
+}
+
+module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+ var from;
+ var to = toObject(target);
+ var symbols;
+
+ for (var s = 1; s < arguments.length; s++) {
+ from = Object(arguments[s]);
+
+ for (var key in from) {
+ if (hasOwnProperty.call(from, key)) {
+ to[key] = from[key];
+ }
+ }
+
+ if (getOwnPropertySymbols) {
+ symbols = getOwnPropertySymbols(from);
+ for (var i = 0; i < symbols.length; i++) {
+ if (propIsEnumerable.call(from, symbols[i])) {
+ to[symbols[i]] = from[symbols[i]];
+ }
+ }
+ }
+ }
+
+ return to;
+};
diff --git a/node_modules/object-assign/license b/node_modules/object-assign/license
new file mode 100644
index 0000000..654d0bf
--- /dev/null
+++ b/node_modules/object-assign/license
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+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/node_modules/object-assign/package.json b/node_modules/object-assign/package.json
new file mode 100644
index 0000000..503eb1e
--- /dev/null
+++ b/node_modules/object-assign/package.json
@@ -0,0 +1,42 @@
+{
+ "name": "object-assign",
+ "version": "4.1.1",
+ "description": "ES2015 `Object.assign()` ponyfill",
+ "license": "MIT",
+ "repository": "sindresorhus/object-assign",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "scripts": {
+ "test": "xo && ava",
+ "bench": "matcha bench.js"
+ },
+ "files": [
+ "index.js"
+ ],
+ "keywords": [
+ "object",
+ "assign",
+ "extend",
+ "properties",
+ "es2015",
+ "ecmascript",
+ "harmony",
+ "ponyfill",
+ "prollyfill",
+ "polyfill",
+ "shim",
+ "browser"
+ ],
+ "devDependencies": {
+ "ava": "^0.16.0",
+ "lodash": "^4.16.4",
+ "matcha": "^0.7.0",
+ "xo": "^0.16.0"
+ }
+}
diff --git a/node_modules/object-assign/readme.md b/node_modules/object-assign/readme.md
new file mode 100644
index 0000000..1be09d3
--- /dev/null
+++ b/node_modules/object-assign/readme.md
@@ -0,0 +1,61 @@
+# object-assign [](https://travis-ci.org/sindresorhus/object-assign)
+
+> ES2015 [`Object.assign()`](http://www.2ality.com/2014/01/object-assign.html) [ponyfill](https://ponyfill.com)
+
+
+## Use the built-in
+
+Node.js 4 and up, as well as every evergreen browser (Chrome, Edge, Firefox, Opera, Safari),
+support `Object.assign()` :tada:. If you target only those environments, then by all
+means, use `Object.assign()` instead of this package.
+
+
+## Install
+
+```
+$ npm install --save object-assign
+```
+
+
+## Usage
+
+```js
+const objectAssign = require('object-assign');
+
+objectAssign({foo: 0}, {bar: 1});
+//=> {foo: 0, bar: 1}
+
+// multiple sources
+objectAssign({foo: 0}, {bar: 1}, {baz: 2});
+//=> {foo: 0, bar: 1, baz: 2}
+
+// overwrites equal keys
+objectAssign({foo: 0}, {foo: 1}, {foo: 2});
+//=> {foo: 2}
+
+// ignores null and undefined sources
+objectAssign({foo: 0}, null, {bar: 1}, undefined);
+//=> {foo: 0, bar: 1}
+```
+
+
+## API
+
+### objectAssign(target, [source, ...])
+
+Assigns enumerable own properties of `source` objects to the `target` object and returns the `target` object. Additional `source` objects will overwrite previous ones.
+
+
+## Resources
+
+- [ES2015 spec - Object.assign](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign)
+
+
+## Related
+
+- [deep-assign](https://github.com/sindresorhus/deep-assign) - Recursive `Object.assign()`
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/node_modules/object-inspect/CHANGELOG.md b/node_modules/object-inspect/CHANGELOG.md
index d42237c..056fbcc 100644
--- a/node_modules/object-inspect/CHANGELOG.md
+++ b/node_modules/object-inspect/CHANGELOG.md
@@ -5,6 +5,40 @@ All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [v1.13.2](https://github.com/inspect-js/object-inspect/compare/v1.13.1...v1.13.2) - 2024-06-21
+
+### Commits
+
+- [readme] update badges [`8a51e6b`](https://github.com/inspect-js/object-inspect/commit/8a51e6bedaf389ec40cc4659e9df53e8543d176e)
+- [Dev Deps] update `@ljharb/eslint-config`, `tape` [`ef05f58`](https://github.com/inspect-js/object-inspect/commit/ef05f58c9761a41416ab907299bf0fa79517014b)
+- [Dev Deps] update `error-cause`, `has-tostringtag`, `tape` [`c0c6c26`](https://github.com/inspect-js/object-inspect/commit/c0c6c26c44cee6671f7c5d43d2b91d27c5c00d90)
+- [Fix] Don't throw when `global` is not defined [`d4d0965`](https://github.com/inspect-js/object-inspect/commit/d4d096570f7dbd0e03266a96de11d05eb7b63e0f)
+- [meta] add missing `engines.node` [`17a352a`](https://github.com/inspect-js/object-inspect/commit/17a352af6fe1ba6b70a19081674231eb1a50c940)
+- [Dev Deps] update `globalthis` [`9c08884`](https://github.com/inspect-js/object-inspect/commit/9c08884aa662a149e2f11403f413927736b97da7)
+- [Dev Deps] update `error-cause` [`6af352d`](https://github.com/inspect-js/object-inspect/commit/6af352d7c3929a4cc4c55768c27bf547a5e900f4)
+- [Dev Deps] update `npmignore` [`94e617d`](https://github.com/inspect-js/object-inspect/commit/94e617d38831722562fa73dff4c895746861d267)
+- [Dev Deps] update `mock-property` [`2ac24d7`](https://github.com/inspect-js/object-inspect/commit/2ac24d7e58cd388ad093c33249e413e05bbfd6c3)
+- [Dev Deps] update `tape` [`46125e5`](https://github.com/inspect-js/object-inspect/commit/46125e58f1d1dcfb170ed3d1ea69da550ea8d77b)
+
+## [v1.13.1](https://github.com/inspect-js/object-inspect/compare/v1.13.0...v1.13.1) - 2023-10-19
+
+### Commits
+
+- [Fix] in IE 8, global can !== window despite them being prototypes of each other [`30d0859`](https://github.com/inspect-js/object-inspect/commit/30d0859dc4606cf75c2410edcd5d5c6355f8d372)
+
+## [v1.13.0](https://github.com/inspect-js/object-inspect/compare/v1.12.3...v1.13.0) - 2023-10-14
+
+### Commits
+
+- [New] add special handling for the global object [`431bab2`](https://github.com/inspect-js/object-inspect/commit/431bab21a490ee51d35395966a504501e8c685da)
+- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`fd4f619`](https://github.com/inspect-js/object-inspect/commit/fd4f6193562b4b0e95dcf5c0201b4e8cbbc4f58d)
+- [Dev Deps] update `mock-property`, `tape` [`b453f6c`](https://github.com/inspect-js/object-inspect/commit/b453f6ceeebf8a1b738a1029754092e0367a4134)
+- [Dev Deps] update `error-cause` [`e8ffc57`](https://github.com/inspect-js/object-inspect/commit/e8ffc577d73b92bb6a4b00c44f14e3319e374888)
+- [Dev Deps] update `tape` [`054b8b9`](https://github.com/inspect-js/object-inspect/commit/054b8b9b98633284cf989e582450ebfbbe53503c)
+- [Dev Deps] temporarily remove `aud` due to breaking change in transitive deps [`2476845`](https://github.com/inspect-js/object-inspect/commit/2476845e0678dd290c541c81cd3dec8420782c52)
+- [Dev Deps] pin `glob`, since v10.3.8+ requires a broken `jackspeak` [`383fa5e`](https://github.com/inspect-js/object-inspect/commit/383fa5eebc0afd705cc778a4b49d8e26452e49a8)
+- [Dev Deps] pin `jackspeak` since 2.1.2+ depends on npm aliases, which kill the install process in npm < 6 [`68c244c`](https://github.com/inspect-js/object-inspect/commit/68c244c5174cdd877e5dcb8ee90aa3f44b2f25be)
+
## [v1.12.3](https://github.com/inspect-js/object-inspect/compare/v1.12.2...v1.12.3) - 2023-01-12
### Commits
diff --git a/node_modules/object-inspect/index.js b/node_modules/object-inspect/index.js
index 8496225..eb89faf 100644
--- a/node_modules/object-inspect/index.js
+++ b/node_modules/object-inspect/index.js
@@ -239,6 +239,17 @@ module.exports = function inspect_(obj, options, depth, seen) {
if (isString(obj)) {
return markBoxed(inspect(String(obj)));
}
+ // note: in IE 8, sometimes `global !== window` but both are the prototypes of each other
+ /* eslint-env browser */
+ if (typeof window !== 'undefined' && obj === window) {
+ return '{ [object Window] }';
+ }
+ if (
+ (typeof globalThis !== 'undefined' && obj === globalThis)
+ || (typeof global !== 'undefined' && obj === global)
+ ) {
+ return '{ [object globalThis] }';
+ }
if (!isDate(obj) && !isRegExp(obj)) {
var ys = arrObjKeys(obj, inspect);
var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
diff --git a/node_modules/object-inspect/package.json b/node_modules/object-inspect/package.json
index 5f6d5cf..9974d21 100644
--- a/node_modules/object-inspect/package.json
+++ b/node_modules/object-inspect/package.json
@@ -1,29 +1,33 @@
{
"name": "object-inspect",
- "version": "1.12.3",
+ "version": "1.13.2",
"description": "string representations of objects in node and the browser",
"main": "index.js",
"sideEffects": false,
"devDependencies": {
- "@ljharb/eslint-config": "^21.0.1",
+ "@ljharb/eslint-config": "^21.1.1",
"@pkgjs/support": "^0.0.6",
- "aud": "^2.0.2",
"auto-changelog": "^2.4.0",
"core-js": "^2.6.12",
- "error-cause": "^1.0.5",
+ "error-cause": "^1.0.8",
"es-value-fixtures": "^1.4.2",
"eslint": "=8.8.0",
"for-each": "^0.3.3",
"functions-have-names": "^1.2.3",
- "has-tostringtag": "^1.0.0",
+ "glob": "=10.3.7",
+ "globalthis": "^1.0.4",
+ "has-symbols": "^1.0.3",
+ "has-tostringtag": "^1.0.2",
"in-publish": "^2.0.1",
+ "jackspeak": "=2.1.1",
"make-arrow-function": "^1.2.0",
- "mock-property": "^1.0.0",
- "npmignore": "^0.3.0",
+ "mock-property": "^1.0.3",
+ "npmignore": "^0.3.1",
"nyc": "^10.3.2",
"safe-publish-latest": "^2.0.0",
+ "safer-buffer": "^2.1.2",
"string.prototype.repeat": "^1.0.0",
- "tape": "^5.6.1"
+ "tape": "^5.8.1"
},
"scripts": {
"prepack": "npmignore --auto --commentLines=autogenerated",
@@ -93,5 +97,8 @@
"./test-core-js.js"
]
},
- "support": true
+ "support": true,
+ "engines": {
+ "node": ">= 0.4"
+ }
}
diff --git a/node_modules/object-inspect/readme.markdown b/node_modules/object-inspect/readme.markdown
index 9ff6bec..f91617d 100644
--- a/node_modules/object-inspect/readme.markdown
+++ b/node_modules/object-inspect/readme.markdown
@@ -1,15 +1,13 @@
-# object-inspect [![Version Badge][2]][1]
+# object-inspect [![Version Badge][npm-version-svg]][package-url]
string representations of objects in node and the browser
[![github actions][actions-image]][actions-url]
[![coverage][codecov-image]][codecov-url]
-[![dependency status][5]][6]
-[![dev dependency status][7]][8]
[![License][license-image]][license-url]
[![Downloads][downloads-image]][downloads-url]
-[![npm badge][11]][1]
+[![npm badge][npm-badge-png]][package-url]
# example
@@ -69,13 +67,13 @@ npm install object-inspect
MIT
-[1]: https://npmjs.org/package/object-inspect
-[2]: https://versionbadg.es/inspect-js/object-inspect.svg
-[5]: https://david-dm.org/inspect-js/object-inspect.svg
-[6]: https://david-dm.org/inspect-js/object-inspect
-[7]: https://david-dm.org/inspect-js/object-inspect/dev-status.svg
-[8]: https://david-dm.org/inspect-js/object-inspect#info=devDependencies
-[11]: https://nodei.co/npm/object-inspect.png?downloads=true&stars=true
+[package-url]: https://npmjs.org/package/object-inspect
+[npm-version-svg]: https://versionbadg.es/inspect-js/object-inspect.svg
+[deps-svg]: https://david-dm.org/inspect-js/object-inspect.svg
+[deps-url]: https://david-dm.org/inspect-js/object-inspect
+[dev-deps-svg]: https://david-dm.org/inspect-js/object-inspect/dev-status.svg
+[dev-deps-url]: https://david-dm.org/inspect-js/object-inspect#info=devDependencies
+[npm-badge-png]: https://nodei.co/npm/object-inspect.png?downloads=true&stars=true
[license-image]: https://img.shields.io/npm/l/object-inspect.svg
[license-url]: LICENSE
[downloads-image]: https://img.shields.io/npm/dm/object-inspect.svg
diff --git a/node_modules/object-inspect/test/global.js b/node_modules/object-inspect/test/global.js
new file mode 100644
index 0000000..c57216a
--- /dev/null
+++ b/node_modules/object-inspect/test/global.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var inspect = require('../');
+
+var test = require('tape');
+var globalThis = require('globalthis')();
+
+test('global object', function (t) {
+ /* eslint-env browser */
+ var expected = typeof window === 'undefined' ? 'globalThis' : 'Window';
+ t.equal(
+ inspect([globalThis]),
+ '[ { [object ' + expected + '] } ]'
+ );
+
+ t.end();
+});
diff --git a/node_modules/path-parse/LICENSE b/node_modules/path-parse/LICENSE
new file mode 100644
index 0000000..810f3db
--- /dev/null
+++ b/node_modules/path-parse/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Javier Blanco
+
+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/node_modules/path-parse/README.md b/node_modules/path-parse/README.md
new file mode 100644
index 0000000..05097f8
--- /dev/null
+++ b/node_modules/path-parse/README.md
@@ -0,0 +1,42 @@
+# path-parse [](https://travis-ci.org/jbgutierrez/path-parse)
+
+> Node.js [`path.parse(pathString)`](https://nodejs.org/api/path.html#path_path_parse_pathstring) [ponyfill](https://ponyfill.com).
+
+## Install
+
+```
+$ npm install --save path-parse
+```
+
+## Usage
+
+```js
+var pathParse = require('path-parse');
+
+pathParse('/home/user/dir/file.txt');
+//=> {
+// root : "/",
+// dir : "/home/user/dir",
+// base : "file.txt",
+// ext : ".txt",
+// name : "file"
+// }
+```
+
+## API
+
+See [`path.parse(pathString)`](https://nodejs.org/api/path.html#path_path_parse_pathstring) docs.
+
+### pathParse(path)
+
+### pathParse.posix(path)
+
+The Posix specific version.
+
+### pathParse.win32(path)
+
+The Windows specific version.
+
+## License
+
+MIT © [Javier Blanco](http://jbgutierrez.info)
diff --git a/node_modules/path-parse/index.js b/node_modules/path-parse/index.js
new file mode 100644
index 0000000..f062d0a
--- /dev/null
+++ b/node_modules/path-parse/index.js
@@ -0,0 +1,75 @@
+'use strict';
+
+var isWindows = process.platform === 'win32';
+
+// Regex to split a windows path into into [dir, root, basename, name, ext]
+var splitWindowsRe =
+ /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
+
+var win32 = {};
+
+function win32SplitPath(filename) {
+ return splitWindowsRe.exec(filename).slice(1);
+}
+
+win32.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
+ }
+ var allParts = win32SplitPath(pathString);
+ if (!allParts || allParts.length !== 5) {
+ throw new TypeError("Invalid path '" + pathString + "'");
+ }
+ return {
+ root: allParts[1],
+ dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[4],
+ name: allParts[3]
+ };
+};
+
+
+
+// Split a filename into [dir, root, basename, name, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+ /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
+var posix = {};
+
+
+function posixSplitPath(filename) {
+ return splitPathRe.exec(filename).slice(1);
+}
+
+
+posix.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
+ }
+ var allParts = posixSplitPath(pathString);
+ if (!allParts || allParts.length !== 5) {
+ throw new TypeError("Invalid path '" + pathString + "'");
+ }
+
+ return {
+ root: allParts[1],
+ dir: allParts[0].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[4],
+ name: allParts[3],
+ };
+};
+
+
+if (isWindows)
+ module.exports = win32.parse;
+else /* posix */
+ module.exports = posix.parse;
+
+module.exports.posix = posix.parse;
+module.exports.win32 = win32.parse;
diff --git a/node_modules/path-parse/package.json b/node_modules/path-parse/package.json
new file mode 100644
index 0000000..36c23f8
--- /dev/null
+++ b/node_modules/path-parse/package.json
@@ -0,0 +1,33 @@
+{
+ "name": "path-parse",
+ "version": "1.0.7",
+ "description": "Node.js path.parse() ponyfill",
+ "main": "index.js",
+ "scripts": {
+ "test": "node test.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/jbgutierrez/path-parse.git"
+ },
+ "keywords": [
+ "path",
+ "paths",
+ "file",
+ "dir",
+ "parse",
+ "built-in",
+ "util",
+ "utils",
+ "core",
+ "ponyfill",
+ "polyfill",
+ "shim"
+ ],
+ "author": "Javier Blanco ",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/jbgutierrez/path-parse/issues"
+ },
+ "homepage": "https://github.com/jbgutierrez/path-parse#readme"
+}
diff --git a/node_modules/path-to-regexp/History.md b/node_modules/path-to-regexp/History.md
deleted file mode 100644
index 7f65878..0000000
--- a/node_modules/path-to-regexp/History.md
+++ /dev/null
@@ -1,36 +0,0 @@
-0.1.7 / 2015-07-28
-==================
-
- * Fixed regression with escaped round brackets and matching groups.
-
-0.1.6 / 2015-06-19
-==================
-
- * Replace `index` feature by outputting all parameters, unnamed and named.
-
-0.1.5 / 2015-05-08
-==================
-
- * Add an index property for position in match result.
-
-0.1.4 / 2015-03-05
-==================
-
- * Add license information
-
-0.1.3 / 2014-07-06
-==================
-
- * Better array support
- * Improved support for trailing slash in non-ending mode
-
-0.1.0 / 2014-03-06
-==================
-
- * add options.end
-
-0.0.2 / 2013-02-10
-==================
-
- * Update to match current express
- * add .license property to component.json
diff --git a/node_modules/path-to-regexp/index.js b/node_modules/path-to-regexp/index.js
index 500d1da..1150335 100644
--- a/node_modules/path-to-regexp/index.js
+++ b/node_modules/path-to-regexp/index.js
@@ -1,13 +1,13 @@
/**
- * Expose `pathtoRegexp`.
+ * Expose `pathToRegexp`.
*/
-module.exports = pathtoRegexp;
+module.exports = pathToRegexp;
/**
* Match matching groups in a regular expression.
*/
-var MATCHING_GROUP_REGEXP = /\((?!\?)/g;
+var MATCHING_GROUP_REGEXP = /\\.|\((?:\?<(.*?)>)?(?!\?)/g;
/**
* Normalize the given path string,
@@ -25,22 +25,27 @@ var MATCHING_GROUP_REGEXP = /\((?!\?)/g;
* @api private
*/
-function pathtoRegexp(path, keys, options) {
+function pathToRegexp(path, keys, options) {
options = options || {};
keys = keys || [];
var strict = options.strict;
var end = options.end !== false;
var flags = options.sensitive ? '' : 'i';
+ var lookahead = options.lookahead !== false;
var extraOffset = 0;
var keysOffset = keys.length;
var i = 0;
var name = 0;
+ var pos = 0;
+ var backtrack = '';
var m;
if (path instanceof RegExp) {
while (m = MATCHING_GROUP_REGEXP.exec(path.source)) {
+ if (m[0][0] === '\\') continue;
+
keys.push({
- name: name++,
+ name: m[1] || name++,
optional: false,
offset: m.index
});
@@ -54,20 +59,47 @@ function pathtoRegexp(path, keys, options) {
// the same keys and options instance into every generation to get
// consistent matching groups before we join the sources together.
path = path.map(function (value) {
- return pathtoRegexp(value, keys, options).source;
+ return pathToRegexp(value, keys, options).source;
});
- return new RegExp('(?:' + path.join('|') + ')', flags);
+ return new RegExp(path.join('|'), flags);
}
- path = ('^' + path + (strict ? '' : path[path.length - 1] === '/' ? '?' : '/?'))
- .replace(/\/\(/g, '/(?:')
- .replace(/([\/\.])/g, '\\$1')
- .replace(/(\\\/)?(\\\.)?:(\w+)(\(.*?\))?(\*)?(\?)?/g, function (match, slash, format, key, capture, star, optional, offset) {
+ path = path.replace(
+ /\\.|(\/)?(\.)?:(\w+)(\(.*?\))?(\*)?(\?)?|[.*]|\/\(/g,
+ function (match, slash, format, key, capture, star, optional, offset) {
+ pos = offset + match.length;
+
+ if (match[0] === '\\') {
+ backtrack += match;
+ return match;
+ }
+
+ if (match === '.') {
+ backtrack += '\\.';
+ extraOffset += 1;
+ return '\\.';
+ }
+
+ backtrack = slash || format ? '' : path.slice(pos, offset);
+
+ if (match === '*') {
+ extraOffset += 3;
+ return '(.*)';
+ }
+
+ if (match === '/(') {
+ backtrack += '/';
+ extraOffset += 2;
+ return '/(?:';
+ }
+
slash = slash || '';
- format = format || '';
- capture = capture || '([^\\/' + format + ']+?)';
+ format = format ? '\\.' : '';
optional = optional || '';
+ capture = capture ?
+ capture.replace(/\\.|\*/, function (m) { return m === '*' ? '(.*)' : m; }) :
+ (backtrack ? '((?:(?!/|' + backtrack + ').)+?)' : '([^/' + format + ']+?)');
keys.push({
name: key,
@@ -75,41 +107,20 @@ function pathtoRegexp(path, keys, options) {
offset: offset + extraOffset
});
- var result = ''
- + (optional ? '' : slash)
- + '(?:'
- + format + (optional ? slash : '') + capture
- + (star ? '((?:[\\/' + format + '].+?)?)' : '')
+ var result = '(?:'
+ + format + slash + capture
+ + (star ? '((?:[/' + format + '].+?)?)' : '')
+ ')'
+ optional;
extraOffset += result.length - match.length;
return result;
- })
- .replace(/\*/g, function (star, index) {
- var len = keys.length
-
- while (len-- > keysOffset && keys[len].offset > index) {
- keys[len].offset += 3; // Replacement length minus asterisk length.
- }
-
- return '(.*)';
});
// This is a workaround for handling unnamed matching groups.
while (m = MATCHING_GROUP_REGEXP.exec(path)) {
- var escapeCount = 0;
- var index = m.index;
-
- while (path.charAt(--index) === '\\') {
- escapeCount++;
- }
-
- // It's possible to escape the bracket.
- if (escapeCount % 2 === 1) {
- continue;
- }
+ if (m[0][0] === '\\') continue;
if (keysOffset + i === keys.length || keys[keysOffset + i].offset > m.index) {
keys.splice(keysOffset + i, 0, {
@@ -122,8 +133,14 @@ function pathtoRegexp(path, keys, options) {
i++;
}
+ path += strict ? '' : path[path.length - 1] === '/' ? '?' : '/?';
+
// If the path is non-ending, match until the end or a slash.
- path += (end ? '$' : (path[path.length - 1] === '/' ? '' : '(?=\\/|$)'));
+ if (end) {
+ path += '$';
+ } else if (path[path.length - 1] !== '/') {
+ path += lookahead ? '(?=/|$)' : '(?:/|$)';
+ }
- return new RegExp(path, flags);
+ return new RegExp('^' + path, flags);
};
diff --git a/node_modules/path-to-regexp/package.json b/node_modules/path-to-regexp/package.json
index d4e51b5..0fe1eed 100644
--- a/node_modules/path-to-regexp/package.json
+++ b/node_modules/path-to-regexp/package.json
@@ -1,7 +1,7 @@
{
"name": "path-to-regexp",
"description": "Express style path to RegExp utility",
- "version": "0.1.7",
+ "version": "0.1.10",
"files": [
"index.js",
"LICENSE"
@@ -21,7 +21,7 @@
"license": "MIT",
"repository": {
"type": "git",
- "url": "https://github.com/component/path-to-regexp.git"
+ "url": "https://github.com/pillarjs/path-to-regexp.git"
},
"devDependencies": {
"mocha": "^1.17.1",
diff --git a/node_modules/promise/.jshintrc b/node_modules/promise/.jshintrc
new file mode 100644
index 0000000..47c256f
--- /dev/null
+++ b/node_modules/promise/.jshintrc
@@ -0,0 +1,5 @@
+{
+ "asi": true,
+ "node": true,
+ "strict": true
+}
diff --git a/node_modules/promise/.npmignore b/node_modules/promise/.npmignore
new file mode 100644
index 0000000..ad5be4a
--- /dev/null
+++ b/node_modules/promise/.npmignore
@@ -0,0 +1,7 @@
+components
+node_modules
+test
+.gitignore
+.travis.yml
+component.json
+coverage
diff --git a/node_modules/promise/LICENSE b/node_modules/promise/LICENSE
new file mode 100644
index 0000000..7a1f763
--- /dev/null
+++ b/node_modules/promise/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Forbes Lindesay
+
+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/node_modules/promise/Readme.md b/node_modules/promise/Readme.md
new file mode 100644
index 0000000..9e281a7
--- /dev/null
+++ b/node_modules/promise/Readme.md
@@ -0,0 +1,231 @@
+
+# promise
+
+This is a simple implementation of Promises. It is a super set of ES6 Promises designed to have readable, performant code and to provide just the extensions that are absolutely necessary for using promises today.
+
+For detailed tutorials on its use, see www.promisejs.org
+
+**N.B.** This promise exposes internals via underscore (`_`) prefixed properties. If you use these, your code will break with each new release.
+
+[![travis][travis-image]][travis-url]
+[![dep][dep-image]][dep-url]
+[![npm][npm-image]][npm-url]
+[![downloads][downloads-image]][downloads-url]
+
+[travis-image]: https://img.shields.io/travis/then/promise.svg?style=flat
+[travis-url]: https://travis-ci.org/then/promise
+[dep-image]: https://img.shields.io/david/then/promise.svg?style=flat
+[dep-url]: https://david-dm.org/then/promise
+[npm-image]: https://img.shields.io/npm/v/promise.svg?style=flat
+[npm-url]: https://npmjs.org/package/promise
+[downloads-image]: https://img.shields.io/npm/dm/promise.svg?style=flat
+[downloads-url]: https://npmjs.org/package/promise
+
+## Installation
+
+**Server:**
+
+ $ npm install promise
+
+**Client:**
+
+You can use browserify on the client, or use the pre-compiled script that acts as a polyfill.
+
+```html
+
+```
+
+Note that the [es5-shim](https://github.com/es-shims/es5-shim) must be loaded before this library to support browsers pre IE9.
+
+```html
+
+```
+
+## Usage
+
+The example below shows how you can load the promise library (in a way that works on both client and server using node or browserify). It then demonstrates creating a promise from scratch. You simply call `new Promise(fn)`. There is a complete specification for what is returned by this method in [Promises/A+](http://promises-aplus.github.com/promises-spec/).
+
+```javascript
+var Promise = require('promise');
+
+var promise = new Promise(function (resolve, reject) {
+ get('http://www.google.com', function (err, res) {
+ if (err) reject(err);
+ else resolve(res);
+ });
+});
+```
+
+If you need [domains](https://iojs.org/api/domain.html) support, you should instead use:
+
+```js
+var Promise = require('promise/domains');
+```
+
+If you are in an environment that implements `setImmediate` and don't want the optimisations provided by asap, you can use:
+
+```js
+var Promise = require('promise/setimmediate');
+```
+
+If you only want part of the features, e.g. just a pure ES6 polyfill:
+
+```js
+var Promise = require('promise/lib/es6-extensions');
+// or require('promise/domains/es6-extensions');
+// or require('promise/setimmediate/es6-extensions');
+```
+
+## Unhandled Rejections
+
+By default, promises silence any unhandled rejections.
+
+You can enable logging of unhandled ReferenceErrors and TypeErrors via:
+
+```js
+require('promise/lib/rejection-tracking').enable();
+```
+
+Due to the performance cost, you should only do this during development.
+
+You can enable logging of all unhandled rejections if you need to debug an exception you think is being swallowed by promises:
+
+```js
+require('promise/lib/rejection-tracking').enable(
+ {allRejections: true}
+);
+```
+
+Due to the high probability of false positives, I only recommend using this when debugging specific issues that you think may be being swallowed. For the preferred debugging method, see `Promise#done(onFulfilled, onRejected)`.
+
+`rejection-tracking.enable(options)` takes the following options:
+
+ - allRejections (`boolean`) - track all exceptions, not just reference errors and type errors. Note that this has a high probability of resulting in false positives if your code loads data optimisticly
+ - whitelist (`Array`) - this defaults to `[ReferenceError, TypeError]` but you can override it with your own list of error constructors to track.
+ - `onUnhandled(id, error)` and `onHandled(id, error)` - you can use these to provide your own customised display for errors. Note that if possible you should indicate that the error was a false positive if `onHandled` is called. `onHandled` is only called if `onUnhandled` has already been called.
+
+To reduce the chance of false-positives there is a delay of up to 2 seconds before errors are logged. This means that if you attach an error handler within 2 seconds, it won't be logged as a false positive. ReferenceErrors and TypeErrors are only subject to a 100ms delay due to the higher likelihood that the error is due to programmer error.
+
+## API
+
+Before all examples, you will need:
+
+```js
+var Promise = require('promise');
+```
+
+### new Promise(resolver)
+
+This creates and returns a new promise. `resolver` must be a function. The `resolver` function is passed two arguments:
+
+ 1. `resolve` should be called with a single argument. If it is called with a non-promise value then the promise is fulfilled with that value. If it is called with a promise (A) then the returned promise takes on the state of that new promise (A).
+ 2. `reject` should be called with a single argument. The returned promise will be rejected with that argument.
+
+### Static Functions
+
+ These methods are invoked by calling `Promise.methodName`.
+
+#### Promise.resolve(value)
+
+(deprecated aliases: `Promise.from(value)`, `Promise.cast(value)`)
+
+Converts values and foreign promises into Promises/A+ promises. If you pass it a value then it returns a Promise for that value. If you pass it something that is close to a promise (such as a jQuery attempt at a promise) it returns a Promise that takes on the state of `value` (rejected or fulfilled).
+
+#### Promise.reject(value)
+
+Returns a rejected promise with the given value.
+
+#### Promise.all(array)
+
+Returns a promise for an array. If it is called with a single argument that `Array.isArray` then this returns a promise for a copy of that array with any promises replaced by their fulfilled values. e.g.
+
+```js
+Promise.all([Promise.resolve('a'), 'b', Promise.resolve('c')])
+ .then(function (res) {
+ assert(res[0] === 'a')
+ assert(res[1] === 'b')
+ assert(res[2] === 'c')
+ })
+```
+
+#### Promise.denodeify(fn)
+
+_Non Standard_
+
+Takes a function which accepts a node style callback and returns a new function that returns a promise instead.
+
+e.g.
+
+```javascript
+var fs = require('fs')
+
+var read = Promise.denodeify(fs.readFile)
+var write = Promise.denodeify(fs.writeFile)
+
+var p = read('foo.json', 'utf8')
+ .then(function (str) {
+ return write('foo.json', JSON.stringify(JSON.parse(str), null, ' '), 'utf8')
+ })
+```
+
+#### Promise.nodeify(fn)
+
+_Non Standard_
+
+The twin to `denodeify` is useful when you want to export an API that can be used by people who haven't learnt about the brilliance of promises yet.
+
+```javascript
+module.exports = Promise.nodeify(awesomeAPI)
+function awesomeAPI(a, b) {
+ return download(a, b)
+}
+```
+
+If the last argument passed to `module.exports` is a function, then it will be treated like a node.js callback and not parsed on to the child function, otherwise the API will just return a promise.
+
+### Prototype Methods
+
+These methods are invoked on a promise instance by calling `myPromise.methodName`
+
+### Promise#then(onFulfilled, onRejected)
+
+This method follows the [Promises/A+ spec](http://promises-aplus.github.io/promises-spec/). It explains things very clearly so I recommend you read it.
+
+Either `onFulfilled` or `onRejected` will be called and they will not be called more than once. They will be passed a single argument and will always be called asynchronously (in the next turn of the event loop).
+
+If the promise is fulfilled then `onFulfilled` is called. If the promise is rejected then `onRejected` is called.
+
+The call to `.then` also returns a promise. If the handler that is called returns a promise, the promise returned by `.then` takes on the state of that returned promise. If the handler that is called returns a value that is not a promise, the promise returned by `.then` will be fulfilled with that value. If the handler that is called throws an exception then the promise returned by `.then` is rejected with that exception.
+
+#### Promise#catch(onRejected)
+
+Sugar for `Promise#then(null, onRejected)`, to mirror `catch` in synchronous code.
+
+#### Promise#done(onFulfilled, onRejected)
+
+_Non Standard_
+
+The same semantics as `.then` except that it does not return a promise and any exceptions are re-thrown so that they can be logged (crashing the application in non-browser environments)
+
+#### Promise#nodeify(callback)
+
+_Non Standard_
+
+If `callback` is `null` or `undefined` it just returns `this`. If `callback` is a function it is called with rejection reason as the first argument and result as the second argument (as per the node.js convention).
+
+This lets you write API functions that look like:
+
+```javascript
+function awesomeAPI(foo, bar, callback) {
+ return internalAPI(foo, bar)
+ .then(parseResult)
+ .then(null, retryErrors)
+ .nodeify(callback)
+}
+```
+
+People who use typical node.js style callbacks will be able to just pass a callback and get the expected behavior. The enlightened people can not pass a callback and will get awesome promises.
+
+## License
+
+ MIT
diff --git a/node_modules/promise/build.js b/node_modules/promise/build.js
new file mode 100644
index 0000000..1e028e9
--- /dev/null
+++ b/node_modules/promise/build.js
@@ -0,0 +1,69 @@
+'use strict';
+
+var fs = require('fs');
+var rimraf = require('rimraf');
+var acorn = require('acorn');
+var walk = require('acorn/dist/walk');
+
+var ids = [];
+var names = {};
+
+function getIdFor(name) {
+ if (name in names) return names[name];
+ var id;
+ do {
+ id = '_' + Math.floor(Math.random() * 100);
+ } while (ids.indexOf(id) !== -1)
+ ids.push(id);
+ names[name] = id;
+ return id;
+}
+
+function fixup(src) {
+ var ast = acorn.parse(src);
+ src = src.split('');
+ walk.simple(ast, {
+ MemberExpression: function (node) {
+ if (node.computed) return;
+ if (node.property.type !== 'Identifier') return;
+ if (node.property.name[0] !== '_') return;
+ replace(node.property, getIdFor(node.property.name));
+ }
+ });
+ function source(node) {
+ return src.slice(node.start, node.end).join('');
+ }
+ function replace(node, str) {
+ for (var i = node.start; i < node.end; i++) {
+ src[i] = '';
+ }
+ src[node.start] = str;
+ }
+ return src.join('');
+}
+rimraf.sync(__dirname + '/lib/');
+fs.mkdirSync(__dirname + '/lib/');
+fs.readdirSync(__dirname + '/src').forEach(function (filename) {
+ var src = fs.readFileSync(__dirname + '/src/' + filename, 'utf8');
+ var out = fixup(src);
+ fs.writeFileSync(__dirname + '/lib/' + filename, out);
+});
+
+rimraf.sync(__dirname + '/domains/');
+fs.mkdirSync(__dirname + '/domains/');
+fs.readdirSync(__dirname + '/src').forEach(function (filename) {
+ var src = fs.readFileSync(__dirname + '/src/' + filename, 'utf8');
+ var out = fixup(src);
+ out = out.replace(/require\(\'asap\/raw\'\)/g, "require('asap')");
+ fs.writeFileSync(__dirname + '/domains/' + filename, out);
+});
+
+rimraf.sync(__dirname + '/setimmediate/');
+fs.mkdirSync(__dirname + '/setimmediate/');
+fs.readdirSync(__dirname + '/src').forEach(function (filename) {
+ var src = fs.readFileSync(__dirname + '/src/' + filename, 'utf8');
+ var out = fixup(src);
+ out = out.replace(/var asap \= require\(\'([a-z\/]+)\'\);/g, '');
+ out = out.replace(/asap/g, "setImmediate");
+ fs.writeFileSync(__dirname + '/setimmediate/' + filename, out);
+});
diff --git a/node_modules/promise/core.js b/node_modules/promise/core.js
new file mode 100644
index 0000000..5f332a2
--- /dev/null
+++ b/node_modules/promise/core.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = require('./lib/core.js');
+
+console.error('require("promise/core") is deprecated, use require("promise/lib/core") instead.');
diff --git a/node_modules/promise/domains/core.js b/node_modules/promise/domains/core.js
new file mode 100644
index 0000000..aea4414
--- /dev/null
+++ b/node_modules/promise/domains/core.js
@@ -0,0 +1,213 @@
+'use strict';
+
+var asap = require('asap');
+
+function noop() {}
+
+// States:
+//
+// 0 - pending
+// 1 - fulfilled with _value
+// 2 - rejected with _value
+// 3 - adopted the state of another promise, _value
+//
+// once the state is no longer pending (0) it is immutable
+
+// All `_` prefixed properties will be reduced to `_{random number}`
+// at build time to obfuscate them and discourage their use.
+// We don't use symbols or Object.defineProperty to fully hide them
+// because the performance isn't good enough.
+
+
+// to avoid using try/catch inside critical functions, we
+// extract them to here.
+var LAST_ERROR = null;
+var IS_ERROR = {};
+function getThen(obj) {
+ try {
+ return obj.then;
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+}
+
+function tryCallOne(fn, a) {
+ try {
+ return fn(a);
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+}
+function tryCallTwo(fn, a, b) {
+ try {
+ fn(a, b);
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+}
+
+module.exports = Promise;
+
+function Promise(fn) {
+ if (typeof this !== 'object') {
+ throw new TypeError('Promises must be constructed via new');
+ }
+ if (typeof fn !== 'function') {
+ throw new TypeError('Promise constructor\'s argument is not a function');
+ }
+ this._40 = 0;
+ this._65 = 0;
+ this._55 = null;
+ this._72 = null;
+ if (fn === noop) return;
+ doResolve(fn, this);
+}
+Promise._37 = null;
+Promise._87 = null;
+Promise._61 = noop;
+
+Promise.prototype.then = function(onFulfilled, onRejected) {
+ if (this.constructor !== Promise) {
+ return safeThen(this, onFulfilled, onRejected);
+ }
+ var res = new Promise(noop);
+ handle(this, new Handler(onFulfilled, onRejected, res));
+ return res;
+};
+
+function safeThen(self, onFulfilled, onRejected) {
+ return new self.constructor(function (resolve, reject) {
+ var res = new Promise(noop);
+ res.then(resolve, reject);
+ handle(self, new Handler(onFulfilled, onRejected, res));
+ });
+}
+function handle(self, deferred) {
+ while (self._65 === 3) {
+ self = self._55;
+ }
+ if (Promise._37) {
+ Promise._37(self);
+ }
+ if (self._65 === 0) {
+ if (self._40 === 0) {
+ self._40 = 1;
+ self._72 = deferred;
+ return;
+ }
+ if (self._40 === 1) {
+ self._40 = 2;
+ self._72 = [self._72, deferred];
+ return;
+ }
+ self._72.push(deferred);
+ return;
+ }
+ handleResolved(self, deferred);
+}
+
+function handleResolved(self, deferred) {
+ asap(function() {
+ var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;
+ if (cb === null) {
+ if (self._65 === 1) {
+ resolve(deferred.promise, self._55);
+ } else {
+ reject(deferred.promise, self._55);
+ }
+ return;
+ }
+ var ret = tryCallOne(cb, self._55);
+ if (ret === IS_ERROR) {
+ reject(deferred.promise, LAST_ERROR);
+ } else {
+ resolve(deferred.promise, ret);
+ }
+ });
+}
+function resolve(self, newValue) {
+ // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+ if (newValue === self) {
+ return reject(
+ self,
+ new TypeError('A promise cannot be resolved with itself.')
+ );
+ }
+ if (
+ newValue &&
+ (typeof newValue === 'object' || typeof newValue === 'function')
+ ) {
+ var then = getThen(newValue);
+ if (then === IS_ERROR) {
+ return reject(self, LAST_ERROR);
+ }
+ if (
+ then === self.then &&
+ newValue instanceof Promise
+ ) {
+ self._65 = 3;
+ self._55 = newValue;
+ finale(self);
+ return;
+ } else if (typeof then === 'function') {
+ doResolve(then.bind(newValue), self);
+ return;
+ }
+ }
+ self._65 = 1;
+ self._55 = newValue;
+ finale(self);
+}
+
+function reject(self, newValue) {
+ self._65 = 2;
+ self._55 = newValue;
+ if (Promise._87) {
+ Promise._87(self, newValue);
+ }
+ finale(self);
+}
+function finale(self) {
+ if (self._40 === 1) {
+ handle(self, self._72);
+ self._72 = null;
+ }
+ if (self._40 === 2) {
+ for (var i = 0; i < self._72.length; i++) {
+ handle(self, self._72[i]);
+ }
+ self._72 = null;
+ }
+}
+
+function Handler(onFulfilled, onRejected, promise){
+ this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+ this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+ this.promise = promise;
+}
+
+/**
+ * Take a potentially misbehaving resolver function and make sure
+ * onFulfilled and onRejected are only called once.
+ *
+ * Makes no guarantees about asynchrony.
+ */
+function doResolve(fn, promise) {
+ var done = false;
+ var res = tryCallTwo(fn, function (value) {
+ if (done) return;
+ done = true;
+ resolve(promise, value);
+ }, function (reason) {
+ if (done) return;
+ done = true;
+ reject(promise, reason);
+ });
+ if (!done && res === IS_ERROR) {
+ done = true;
+ reject(promise, LAST_ERROR);
+ }
+}
diff --git a/node_modules/promise/domains/done.js b/node_modules/promise/domains/done.js
new file mode 100644
index 0000000..f879317
--- /dev/null
+++ b/node_modules/promise/domains/done.js
@@ -0,0 +1,13 @@
+'use strict';
+
+var Promise = require('./core.js');
+
+module.exports = Promise;
+Promise.prototype.done = function (onFulfilled, onRejected) {
+ var self = arguments.length ? this.then.apply(this, arguments) : this;
+ self.then(null, function (err) {
+ setTimeout(function () {
+ throw err;
+ }, 0);
+ });
+};
diff --git a/node_modules/promise/domains/es6-extensions.js b/node_modules/promise/domains/es6-extensions.js
new file mode 100644
index 0000000..8ab2666
--- /dev/null
+++ b/node_modules/promise/domains/es6-extensions.js
@@ -0,0 +1,107 @@
+'use strict';
+
+//This file contains the ES6 extensions to the core Promises/A+ API
+
+var Promise = require('./core.js');
+
+module.exports = Promise;
+
+/* Static Functions */
+
+var TRUE = valuePromise(true);
+var FALSE = valuePromise(false);
+var NULL = valuePromise(null);
+var UNDEFINED = valuePromise(undefined);
+var ZERO = valuePromise(0);
+var EMPTYSTRING = valuePromise('');
+
+function valuePromise(value) {
+ var p = new Promise(Promise._61);
+ p._65 = 1;
+ p._55 = value;
+ return p;
+}
+Promise.resolve = function (value) {
+ if (value instanceof Promise) return value;
+
+ if (value === null) return NULL;
+ if (value === undefined) return UNDEFINED;
+ if (value === true) return TRUE;
+ if (value === false) return FALSE;
+ if (value === 0) return ZERO;
+ if (value === '') return EMPTYSTRING;
+
+ if (typeof value === 'object' || typeof value === 'function') {
+ try {
+ var then = value.then;
+ if (typeof then === 'function') {
+ return new Promise(then.bind(value));
+ }
+ } catch (ex) {
+ return new Promise(function (resolve, reject) {
+ reject(ex);
+ });
+ }
+ }
+ return valuePromise(value);
+};
+
+Promise.all = function (arr) {
+ var args = Array.prototype.slice.call(arr);
+
+ return new Promise(function (resolve, reject) {
+ if (args.length === 0) return resolve([]);
+ var remaining = args.length;
+ function res(i, val) {
+ if (val && (typeof val === 'object' || typeof val === 'function')) {
+ if (val instanceof Promise && val.then === Promise.prototype.then) {
+ while (val._65 === 3) {
+ val = val._55;
+ }
+ if (val._65 === 1) return res(i, val._55);
+ if (val._65 === 2) reject(val._55);
+ val.then(function (val) {
+ res(i, val);
+ }, reject);
+ return;
+ } else {
+ var then = val.then;
+ if (typeof then === 'function') {
+ var p = new Promise(then.bind(val));
+ p.then(function (val) {
+ res(i, val);
+ }, reject);
+ return;
+ }
+ }
+ }
+ args[i] = val;
+ if (--remaining === 0) {
+ resolve(args);
+ }
+ }
+ for (var i = 0; i < args.length; i++) {
+ res(i, args[i]);
+ }
+ });
+};
+
+Promise.reject = function (value) {
+ return new Promise(function (resolve, reject) {
+ reject(value);
+ });
+};
+
+Promise.race = function (values) {
+ return new Promise(function (resolve, reject) {
+ values.forEach(function(value){
+ Promise.resolve(value).then(resolve, reject);
+ });
+ });
+};
+
+/* Prototype Methods */
+
+Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+};
diff --git a/node_modules/promise/domains/finally.js b/node_modules/promise/domains/finally.js
new file mode 100644
index 0000000..f5ee0b9
--- /dev/null
+++ b/node_modules/promise/domains/finally.js
@@ -0,0 +1,16 @@
+'use strict';
+
+var Promise = require('./core.js');
+
+module.exports = Promise;
+Promise.prototype['finally'] = function (f) {
+ return this.then(function (value) {
+ return Promise.resolve(f()).then(function () {
+ return value;
+ });
+ }, function (err) {
+ return Promise.resolve(f()).then(function () {
+ throw err;
+ });
+ });
+};
diff --git a/node_modules/promise/domains/index.js b/node_modules/promise/domains/index.js
new file mode 100644
index 0000000..6e674f3
--- /dev/null
+++ b/node_modules/promise/domains/index.js
@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = require('./core.js');
+require('./done.js');
+require('./finally.js');
+require('./es6-extensions.js');
+require('./node-extensions.js');
+require('./synchronous.js');
diff --git a/node_modules/promise/domains/node-extensions.js b/node_modules/promise/domains/node-extensions.js
new file mode 100644
index 0000000..157cddc
--- /dev/null
+++ b/node_modules/promise/domains/node-extensions.js
@@ -0,0 +1,130 @@
+'use strict';
+
+// This file contains then/promise specific extensions that are only useful
+// for node.js interop
+
+var Promise = require('./core.js');
+var asap = require('asap');
+
+module.exports = Promise;
+
+/* Static Functions */
+
+Promise.denodeify = function (fn, argumentCount) {
+ if (
+ typeof argumentCount === 'number' && argumentCount !== Infinity
+ ) {
+ return denodeifyWithCount(fn, argumentCount);
+ } else {
+ return denodeifyWithoutCount(fn);
+ }
+};
+
+var callbackFn = (
+ 'function (err, res) {' +
+ 'if (err) { rj(err); } else { rs(res); }' +
+ '}'
+);
+function denodeifyWithCount(fn, argumentCount) {
+ var args = [];
+ for (var i = 0; i < argumentCount; i++) {
+ args.push('a' + i);
+ }
+ var body = [
+ 'return function (' + args.join(',') + ') {',
+ 'var self = this;',
+ 'return new Promise(function (rs, rj) {',
+ 'var res = fn.call(',
+ ['self'].concat(args).concat([callbackFn]).join(','),
+ ');',
+ 'if (res &&',
+ '(typeof res === "object" || typeof res === "function") &&',
+ 'typeof res.then === "function"',
+ ') {rs(res);}',
+ '});',
+ '};'
+ ].join('');
+ return Function(['Promise', 'fn'], body)(Promise, fn);
+}
+function denodeifyWithoutCount(fn) {
+ var fnLength = Math.max(fn.length - 1, 3);
+ var args = [];
+ for (var i = 0; i < fnLength; i++) {
+ args.push('a' + i);
+ }
+ var body = [
+ 'return function (' + args.join(',') + ') {',
+ 'var self = this;',
+ 'var args;',
+ 'var argLength = arguments.length;',
+ 'if (arguments.length > ' + fnLength + ') {',
+ 'args = new Array(arguments.length + 1);',
+ 'for (var i = 0; i < arguments.length; i++) {',
+ 'args[i] = arguments[i];',
+ '}',
+ '}',
+ 'return new Promise(function (rs, rj) {',
+ 'var cb = ' + callbackFn + ';',
+ 'var res;',
+ 'switch (argLength) {',
+ args.concat(['extra']).map(function (_, index) {
+ return (
+ 'case ' + (index) + ':' +
+ 'res = fn.call(' + ['self'].concat(args.slice(0, index)).concat('cb').join(',') + ');' +
+ 'break;'
+ );
+ }).join(''),
+ 'default:',
+ 'args[argLength] = cb;',
+ 'res = fn.apply(self, args);',
+ '}',
+
+ 'if (res &&',
+ '(typeof res === "object" || typeof res === "function") &&',
+ 'typeof res.then === "function"',
+ ') {rs(res);}',
+ '});',
+ '};'
+ ].join('');
+
+ return Function(
+ ['Promise', 'fn'],
+ body
+ )(Promise, fn);
+}
+
+Promise.nodeify = function (fn) {
+ return function () {
+ var args = Array.prototype.slice.call(arguments);
+ var callback =
+ typeof args[args.length - 1] === 'function' ? args.pop() : null;
+ var ctx = this;
+ try {
+ return fn.apply(this, arguments).nodeify(callback, ctx);
+ } catch (ex) {
+ if (callback === null || typeof callback == 'undefined') {
+ return new Promise(function (resolve, reject) {
+ reject(ex);
+ });
+ } else {
+ asap(function () {
+ callback.call(ctx, ex);
+ })
+ }
+ }
+ }
+};
+
+Promise.prototype.nodeify = function (callback, ctx) {
+ if (typeof callback != 'function') return this;
+
+ this.then(function (value) {
+ asap(function () {
+ callback.call(ctx, null, value);
+ });
+ }, function (err) {
+ asap(function () {
+ callback.call(ctx, err);
+ });
+ });
+};
diff --git a/node_modules/promise/domains/rejection-tracking.js b/node_modules/promise/domains/rejection-tracking.js
new file mode 100644
index 0000000..10ccce3
--- /dev/null
+++ b/node_modules/promise/domains/rejection-tracking.js
@@ -0,0 +1,113 @@
+'use strict';
+
+var Promise = require('./core');
+
+var DEFAULT_WHITELIST = [
+ ReferenceError,
+ TypeError,
+ RangeError
+];
+
+var enabled = false;
+exports.disable = disable;
+function disable() {
+ enabled = false;
+ Promise._37 = null;
+ Promise._87 = null;
+}
+
+exports.enable = enable;
+function enable(options) {
+ options = options || {};
+ if (enabled) disable();
+ enabled = true;
+ var id = 0;
+ var displayId = 0;
+ var rejections = {};
+ Promise._37 = function (promise) {
+ if (
+ promise._65 === 2 && // IS REJECTED
+ rejections[promise._51]
+ ) {
+ if (rejections[promise._51].logged) {
+ onHandled(promise._51);
+ } else {
+ clearTimeout(rejections[promise._51].timeout);
+ }
+ delete rejections[promise._51];
+ }
+ };
+ Promise._87 = function (promise, err) {
+ if (promise._40 === 0) { // not yet handled
+ promise._51 = id++;
+ rejections[promise._51] = {
+ displayId: null,
+ error: err,
+ timeout: setTimeout(
+ onUnhandled.bind(null, promise._51),
+ // For reference errors and type errors, this almost always
+ // means the programmer made a mistake, so log them after just
+ // 100ms
+ // otherwise, wait 2 seconds to see if they get handled
+ matchWhitelist(err, DEFAULT_WHITELIST)
+ ? 100
+ : 2000
+ ),
+ logged: false
+ };
+ }
+ };
+ function onUnhandled(id) {
+ if (
+ options.allRejections ||
+ matchWhitelist(
+ rejections[id].error,
+ options.whitelist || DEFAULT_WHITELIST
+ )
+ ) {
+ rejections[id].displayId = displayId++;
+ if (options.onUnhandled) {
+ rejections[id].logged = true;
+ options.onUnhandled(
+ rejections[id].displayId,
+ rejections[id].error
+ );
+ } else {
+ rejections[id].logged = true;
+ logError(
+ rejections[id].displayId,
+ rejections[id].error
+ );
+ }
+ }
+ }
+ function onHandled(id) {
+ if (rejections[id].logged) {
+ if (options.onHandled) {
+ options.onHandled(rejections[id].displayId, rejections[id].error);
+ } else if (!rejections[id].onUnhandled) {
+ console.warn(
+ 'Promise Rejection Handled (id: ' + rejections[id].displayId + '):'
+ );
+ console.warn(
+ ' This means you can ignore any previous messages of the form "Possible Unhandled Promise Rejection" with id ' +
+ rejections[id].displayId + '.'
+ );
+ }
+ }
+ }
+}
+
+function logError(id, error) {
+ console.warn('Possible Unhandled Promise Rejection (id: ' + id + '):');
+ var errStr = (error && (error.stack || error)) + '';
+ errStr.split('\n').forEach(function (line) {
+ console.warn(' ' + line);
+ });
+}
+
+function matchWhitelist(error, list) {
+ return list.some(function (cls) {
+ return error instanceof cls;
+ });
+}
\ No newline at end of file
diff --git a/node_modules/promise/domains/synchronous.js b/node_modules/promise/domains/synchronous.js
new file mode 100644
index 0000000..4939964
--- /dev/null
+++ b/node_modules/promise/domains/synchronous.js
@@ -0,0 +1,62 @@
+'use strict';
+
+var Promise = require('./core.js');
+
+module.exports = Promise;
+Promise.enableSynchronous = function () {
+ Promise.prototype.isPending = function() {
+ return this.getState() == 0;
+ };
+
+ Promise.prototype.isFulfilled = function() {
+ return this.getState() == 1;
+ };
+
+ Promise.prototype.isRejected = function() {
+ return this.getState() == 2;
+ };
+
+ Promise.prototype.getValue = function () {
+ if (this._65 === 3) {
+ return this._55.getValue();
+ }
+
+ if (!this.isFulfilled()) {
+ throw new Error('Cannot get a value of an unfulfilled promise.');
+ }
+
+ return this._55;
+ };
+
+ Promise.prototype.getReason = function () {
+ if (this._65 === 3) {
+ return this._55.getReason();
+ }
+
+ if (!this.isRejected()) {
+ throw new Error('Cannot get a rejection reason of a non-rejected promise.');
+ }
+
+ return this._55;
+ };
+
+ Promise.prototype.getState = function () {
+ if (this._65 === 3) {
+ return this._55.getState();
+ }
+ if (this._65 === -1 || this._65 === -2) {
+ return 0;
+ }
+
+ return this._65;
+ };
+};
+
+Promise.disableSynchronous = function() {
+ Promise.prototype.isPending = undefined;
+ Promise.prototype.isFulfilled = undefined;
+ Promise.prototype.isRejected = undefined;
+ Promise.prototype.getValue = undefined;
+ Promise.prototype.getReason = undefined;
+ Promise.prototype.getState = undefined;
+};
diff --git a/node_modules/promise/index.d.ts b/node_modules/promise/index.d.ts
new file mode 100644
index 0000000..a199cbc
--- /dev/null
+++ b/node_modules/promise/index.d.ts
@@ -0,0 +1,256 @@
+interface Thenable {
+ /**
+ * Attaches callbacks for the resolution and/or rejection of the ThenPromise.
+ * @param onfulfilled The callback to execute when the ThenPromise is resolved.
+ * @param onrejected The callback to execute when the ThenPromise is rejected.
+ * @returns A ThenPromise for the completion of which ever callback is executed.
+ */
+ then(onfulfilled?: ((value: T) => TResult1 | Thenable) | undefined | null, onrejected?: ((reason: any) => TResult2 | Thenable) | undefined | null): Thenable;
+}
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface ThenPromise {
+ /**
+ * Attaches callbacks for the resolution and/or rejection of the ThenPromise.
+ * @param onfulfilled The callback to execute when the ThenPromise is resolved.
+ * @param onrejected The callback to execute when the ThenPromise is rejected.
+ * @returns A ThenPromise for the completion of which ever callback is executed.
+ */
+ then(onfulfilled?: ((value: T) => TResult1 | Thenable) | undefined | null, onrejected?: ((reason: any) => TResult2 | Thenable) | undefined | null): ThenPromise;
+
+ /**
+ * Attaches a callback for only the rejection of the ThenPromise.
+ * @param onrejected The callback to execute when the ThenPromise is rejected.
+ * @returns A ThenPromise for the completion of the callback.
+ */
+ catch(onrejected?: ((reason: any) => TResult | Thenable) | undefined | null): ThenPromise;
+
+ // Extensions specific to then/promise
+
+ /**
+ * Attaches callbacks for the resolution and/or rejection of the ThenPromise, without returning a new promise.
+ * @param onfulfilled The callback to execute when the ThenPromise is resolved.
+ * @param onrejected The callback to execute when the ThenPromise is rejected.
+ */
+ done(onfulfilled?: ((value: T) => any) | undefined | null, onrejected?: ((reason: any) => any) | undefined | null): void;
+
+
+ /**
+ * Calls a node.js style callback. If none is provided, the promise is returned.
+ */
+ nodeify(callback: void | null): ThenPromise;
+ nodeify(callback: (err: Error, value: T) => void): void;
+}
+
+interface ThenPromiseConstructor {
+ /**
+ * A reference to the prototype.
+ */
+ readonly prototype: ThenPromise;
+
+ /**
+ * Creates a new ThenPromise.
+ * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+ * a resolve callback used resolve the promise with a value or the result of another promise,
+ * and a reject callback used to reject the promise with a provided reason or error.
+ */
+ new (executor: (resolve: (value?: T | Thenable) => void, reject: (reason?: any) => void) => any): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable, T10 | Thenable]): ThenPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable]): ThenPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable]): ThenPromise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable]): ThenPromise<[T1, T2, T3, T4, T5, T6, T7]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable]): ThenPromise<[T1, T2, T3, T4, T5, T6]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable]): ThenPromise<[T1, T2, T3, T4, T5]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable ]): ThenPromise<[T1, T2, T3, T4]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable]): ThenPromise<[T1, T2, T3]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: [T1 | Thenable, T2 | Thenable]): ThenPromise<[T1, T2]>;
+
+ /**
+ * Creates a ThenPromise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any ThenPromise is rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ all(values: (T | Thenable)[]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable, T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable, T10 | Thenable]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable, T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable, T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable, T5 | Thenable, T6 | Thenable, T7 | Thenable]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable, T5 | Thenable, T6 | Thenable]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable, T5 | Thenable]): ThenPromise;
+
+ /**
+ * Creates a ThenPromise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new ThenPromise.
+ */
+ race(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable]): ThenPromise