ali-skills 0.0.21 → 0.0.22

package/node_modules/is-class-hotfix/LICENSE.md

@@ -0,0 +1,21 @@
+MIT license
+
+Copyright (C) 2014 Miguel Mota
+
+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.

package/node_modules/is-class-hotfix/README.md

@@ -0,0 +1,35 @@
+# is-class
+
+Check if function is an ES6 class.
+
+# Install
+
+```bash
+npm install is-class
+```
+
+```bash
+bower install is-class
+```
+
+# Usage
+
+```javascript
+var isClass = require('is-class');
+
+class F {}
+function G() {}
+
+console.log(isClass(F)); // true
+console.log(isClass(G)); // false
+```
+
+# Test
+
+```bash
+npm test
+```
+
+# License
+
+MIT

package/node_modules/is-class-hotfix/bower.json

@@ -0,0 +1,24 @@
+{
+  "name": "is-class",
+  "main": "is-class.js",
+  "version": "0.0.4",
+  "homepage": "https://github.com/miguelmota/is-class",
+  "authors": [
+    "Miguel Mota <miguelmota2@gmail.com>"
+  ],
+  "description": "Check if function is an ES6 class.",
+  "keywords": [
+    "predicate",
+    "function",
+    "class",
+    "es6"
+  ],
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ],
+  "license": "MIT"
+}

package/node_modules/is-class-hotfix/is-class.js

@@ -0,0 +1,28 @@
+(function(root) {
+  var toString = Function.prototype.toString;
+
+  function fnBody(fn) {
+    return toString.call(fn).replace(/^[^{]*{\s*/,'').replace(/\s*}[^}]*$/,'');
+  }
+
+  function isClass(fn) {
+    return (typeof fn === 'function' &&
+            (/^class(?:\s|{)/.test(toString.call(fn)) ||
+              (/^.*classCallCheck\(/.test(fnBody(fn)))) // babel.js
+            );
+  }
+
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = isClass;
+    }
+    exports.isClass = isClass;
+  } else if (typeof define === 'function' && define.amd) {
+    define([], function() {
+      return isClass;
+    });
+  } else {
+    root.isClass = isClass;
+  }
+
+})(this);

package/node_modules/is-class-hotfix/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "is-class-hotfix",
+  "version": "0.0.6",
+  "description": "Check if function is an ES6 class.",
+  "main": "is-class.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "tape test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miguelmota/is-class"
+  },
+  "keywords": [
+    "predicate",
+    "function",
+    "class",
+    "es6"
+  ],
+  "author": "Miguel Mota <hello@miguelmota.com> (http://www.miguelmota.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/miguelmota/is-class/issues"
+  },
+  "homepage": "https://github.com/miguelmota/is-class",
+  "devDependencies": {
+    "tape": "^3.0.3"
+  }
+}

package/node_modules/is-class-hotfix/test/babel-class.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } };
+
+var test = require('tape');
+var isClass = require('../is-class');
+
+test('isClass', function (t) {
+  t.plan(9);
+
+  var F = function F() {
+    _classCallCheck(this, F);
+  };
+
+  function G() {}
+
+  t.true(isClass(F));
+  t.false(isClass(G));
+  t.false(isClass(''));
+  t.false(isClass(0));
+  t.false(isClass(null));
+  t.false(isClass(undefined));
+  t.false(isClass(1));
+  t.false(isClass({}));
+  t.false(isClass([]));
+});
+

package/node_modules/is-class-hotfix/test/is-class.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var test = require('tape');
+var isClass = require('../is-class');
+
+test('isClass', function (t) {
+  t.plan(19);
+
+  class F {}
+  function G() {}
+
+  t.true(isClass(F));
+  t.true(isClass(class{}));
+  t.true(isClass(class{   }));
+  t.true(isClass(class{constructor(){}}));
+  t.true(isClass(class _{}));
+  t.true(isClass(class _FF   {}));
+  t.true(isClass(class B extends(F){}));
+  t.true(isClass(class extends(F){}));
+  t.true(isClass(class extends F{}));
+  t.true(isClass(class extends F {}));
+  t.true(isClass(class extends F {}));
+  t.false(isClass(G));
+  t.false(isClass(''));
+  t.false(isClass(0));
+  t.false(isClass(null));
+  t.false(isClass(undefined));
+  t.false(isClass(1));
+  t.false(isClass({}));
+  t.false(isClass([]));
+});

package/node_modules/is-extendable/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/is-extendable/README.md

@@ -0,0 +1,72 @@
+# is-extendable [![NPM version](https://badge.fury.io/js/is-extendable.svg)](http://badge.fury.io/js/is-extendable)
+
+> Returns true if a value is any of the object types: array, regexp, plain object, function or date. This is useful for determining if a value can be extended, e.g. "can the value have keys?"
+
+## Install
+
+Install with [npm](https://www.npmjs.com/)
+
+```sh
+$ npm i is-extendable --save
+```
+
+## Usage
+
+```js
+var isExtendable = require('is-extendable');
+```
+
+Returns true if the value is any of the following:
+
+* `array`
+* `regexp`
+* `plain object`
+* `function`
+* `date`
+* `error`
+
+## Notes
+
+All objects in JavaScript can have keys, but it's a pain to check for this, since we ether need to verify that the value is not `null` or `undefined` and:
+
+* the value is not a primitive, or
+* that the object is an `object`, `function`
+
+Also note that an `extendable` object is not the same as an [extensible object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible), which is one that (in es6) is not sealed, frozen, or marked as non-extensible using `preventExtensions`.
+
+## Related projects
+
+* [assign-deep](https://github.com/jonschlinkert/assign-deep): Deeply assign the enumerable properties of source objects to a destination object.
+* [extend-shallow](https://github.com/jonschlinkert/extend-shallow): Extend an object with the properties of additional objects. node.js/javascript util.
+* [isobject](https://github.com/jonschlinkert/isobject): Returns true if the value is an object and not an array or null.
+* [is-plain-object](https://github.com/jonschlinkert/is-plain-object): Returns true if an object was created by the `Object` constructor.
+* [is-equal-shallow](https://github.com/jonschlinkert/is-equal-shallow): Does a shallow comparison of two objects, returning false if the keys or values differ.
+* [kind-of](https://github.com/jonschlinkert/kind-of): Get the native type of a value.
+
+## Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm i -d && npm test
+```
+
+## Contributing
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/is-extendable/issues/new)
+
+## Author
+
+**Jon Schlinkert**
+
++ [github/jonschlinkert](https://github.com/jonschlinkert)
++ [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+Copyright © 2015 Jon Schlinkert
+Released under the MIT license.
+
+***
+
+_This file was generated by [verb-cli](https://github.com/assemble/verb-cli) on July 04, 2015._

package/node_modules/is-extendable/index.js

@@ -0,0 +1,13 @@
+/*!
+ * is-extendable <https://github.com/jonschlinkert/is-extendable>
+ *
+ * Copyright (c) 2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+module.exports = function isExtendable(val) {
+  return typeof val !== 'undefined' && val !== null
+    && (typeof val === 'object' || typeof val === 'function');
+};

package/node_modules/is-extendable/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "is-extendable",
+  "description": "Returns true if a value is any of the object types: array, regexp, plain object, function or date. This is useful for determining if a value can be extended, e.g. \"can the value have keys?\"",
+  "version": "0.1.1",
+  "homepage": "https://github.com/jonschlinkert/is-extendable",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/is-extendable",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/is-extendable/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "devDependencies": {
+    "mocha": "*"
+  },
+  "keywords": [
+    "array",
+    "assign",
+    "check",
+    "date",
+    "extend",
+    "extensible",
+    "function",
+    "is",
+    "object",
+    "regex",
+    "test"
+  ],
+  "verbiage": {
+    "related": {
+      "list": [
+        "isobject",
+        "is-plain-object",
+        "kind-of",
+        "is-extendable",
+        "is-equal-shallow",
+        "extend-shallow",
+        "assign-deep"
+      ]
+    }
+  }
+}

package/node_modules/is-type-of/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 dead_horse
+
+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.

package/node_modules/is-type-of/README.md

@@ -0,0 +1,105 @@
+is-type-of
+==========
+
+complete type checking for node, extend [core-util-is](https://github.com/isaacs/core-util-is)
+
+dependencies:
+
+- [core-util-is](https://github.com/isaacs/core-util-is)
+- [is-stream](https://github.com/rvagg/isstream)
+- [is-class](https://github.com/miguelmota/is-class)
+
+## Install
+
+```
+npm install is-type-of
+```
+
+## Example
+
+```
+var is = require('is-type-of');
+
+is.array([1]); // => true
+is.primitive(true); // => true
+is.primitive({}); // => false
+is.generatorFunction(function * () {}); // => true
+is.long(Math.pow(2, 33)); // => true
+is.double(0); // => false
+```
+
+## API
+
+### From [core-util-is](https://github.com/isaacs/core-util-is)
+
+#### is.array(arr)
+
+#### is.boolean(bool)
+
+#### is.null(null)
+
+#### is.nullOrUndefined(null)
+
+#### is.number(num)
+
+#### is.string(str)
+
+#### is.symbol(sym)
+
+#### is.undefined(undef)
+
+#### is.regExp(reg)
+
+#### is.object(obj)
+
+#### is.date(date)
+
+#### is.error(err)
+
+#### is.function(fn)
+
+#### is.primitive(prim)
+
+#### is.buffer(buf)
+
+### from [is-stream](https://github.com/rvagg/isstream)
+
+#### is.stream(stream)
+
+#### is.readableStream(readable)
+
+#### is.writableStream(writable)
+
+#### is.duplexStream(duplex)
+
+### from [is-class](https://github.com/miguelmota/is-class)
+
+#### is.class(obj)
+
+### Extend API
+
+#### is.finite(num)
+
+#### is.NaN(NaN)
+
+#### is.generator(gen)
+
+#### is.generatorFunction(fn)
+
+#### is.promise(fn)
+
+#### is.int(int)
+
+#### is.double(double)
+
+#### is.int32(int)
+
+#### is.long(long)
+
+#### is.Long(Long)
+
+  * Support [Long](https://github.com/dcodeIO/Long.js) instance.
+
+## License
+
+MIT

package/node_modules/is-type-of/index.d.ts

@@ -0,0 +1,65 @@
+export function array(val: any): boolean;
+export function boolean(val: any): boolean;
+
+declare function isNull(val: any): boolean;
+export { isNull as null };
+
+export function nullOrUndefined(val: any): boolean;
+
+export function number(val: any): boolean;
+
+export function string(val: any): boolean;
+
+export function symbol(val: any): boolean;
+
+export function undefined(val: any): boolean;
+
+export function regexp(val: any): boolean;
+export function regExp(val: any): boolean;
+
+export function object(val: any): boolean;
+
+export function date(val: any): val is Date;
+
+export function error(val: any): val is Error;
+
+declare function isFunction(val: any): boolean;
+export { isFunction as function };
+    
+export function primitive(val: any): boolean;
+
+export function buffer(val: any): boolean;
+
+export function stream(val: any): boolean;
+
+export function readableStream(val: any): boolean;
+
+export function writableStream(val: any): boolean;
+
+export function duplexStream(val: any): boolean;
+
+declare function isClass(val: any): boolean;
+export { isClass as class };
+
+export function generator(val: any): boolean;
+
+export function generatorFunction(val: any): boolean;
+
+export function asyncFunction(val: any): boolean;
+
+export function promise(val: any): boolean;
+
+export function int(val: any): boolean;
+
+export function int32(val: any): boolean;
+
+export function long(val: any): boolean;
+
+export function Long(val: any): boolean;
+
+export function double(val: any): boolean;
+export function finite(val: any): boolean;
+export function NaN(val: any): boolean;
+
+export function bigInt(val: any): boolean;
+export function bigint(val: any): boolean;

package/node_modules/is-type-of/index.js

@@ -0,0 +1,125 @@
+'use strict';
+
+var utils = require('core-util-is');
+var isStearm = require('isstream');
+// wait for https://github.com/miguelmota/is-class/pull/6 merge
+var isClass = require('is-class-hotfix');
+
+/**
+ * Expose all methods in core-util-is
+ */
+
+Object.keys(utils).map(function (name) {
+  exports[transform(name)] = utils[name];
+});
+
+/**
+ * Stream detected by isstream
+ */
+
+exports.stream = isStearm;
+exports.readableStream = isStearm.isReadable;
+exports.writableStream = isStearm.isWritable;
+exports.duplexStream = isStearm.isDuplex;
+
+/**
+ * Class detected by is-class
+ */
+ exports.class = isClass;
+
+/**
+ * Extend method
+ */
+
+exports.finite = Number.isFinite;
+
+exports.NaN = Number.isNaN;
+
+exports.generator = function (obj) {
+  return obj
+    && 'function' === typeof obj.next
+    && 'function' === typeof obj.throw;
+};
+
+exports.generatorFunction = function (obj) {
+  return obj
+    && obj.constructor
+    && 'GeneratorFunction' === obj.constructor.name;
+};
+
+exports.asyncFunction = function (obj) {
+  return obj
+    && obj.constructor
+    && 'AsyncFunction' === obj.constructor.name;
+};
+
+exports.promise = function (obj) {
+  return obj
+    && 'function' === typeof obj.then;
+};
+
+var MAX_INT_31 = Math.pow(2, 31);
+
+exports.int = function (obj) {
+  return utils.isNumber(obj)
+    && obj % 1 === 0;
+};
+
+exports.int32 = function (obj) {
+  return exports.int(obj)
+    && obj < MAX_INT_31
+    && obj >= -MAX_INT_31;
+};
+
+exports.long = function (obj) {
+  return exports.int(obj)
+    && (obj >= MAX_INT_31 || obj < -MAX_INT_31);
+};
+
+exports.Long = function (obj) {
+  return exports.object(obj)
+    && exports.number(obj.high)
+    && exports.number(obj.low);
+};
+
+exports.double = function (obj) {
+  return utils.isNumber(obj)
+    && !isNaN(obj)
+    && obj % 1 !== 0;
+};
+
+exports.bigInt = function (obj) {
+  return 'bigint' === typeof obj;
+};
+exports.bigint = exports.bigInt;
+
+/**
+ * override core-util-is
+ */
+
+exports.date = function isDate(obj) {
+  return obj instanceof Date;
+};
+
+exports.regExp = function isRegExp(obj) {
+  return obj instanceof RegExp;
+};
+exports.regexp = exports.regExp;
+
+exports.error = function isError(obj) {
+  return obj instanceof Error;
+};
+
+exports.array = Array.isArray;
+
+/**
+ * transform isNull type to null
+ * @param {[type]} m [description]
+ * @return {[type]} [description]
+ */
+
+function transform(m) {
+  var name = m.slice(2);
+  name = name[0].toLowerCase() + name.slice(1);
+  return name;
+}