ali-skills 0.0.21 → 0.0.23

package/node_modules/json-stringify-safe/test/stringify_test.js

@@ -0,0 +1,246 @@
+var Sinon = require("sinon")
+var stringify = require("..")
+function jsonify(obj) { return JSON.stringify(obj, null, 2) }
+
+describe("Stringify", function() {
+  it("must stringify circular objects", function() {
+    var obj = {name: "Alice"}
+    obj.self = obj
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify({name: "Alice", self: "[Circular ~]"}))
+  })
+
+  it("must stringify circular objects with intermediaries", function() {
+    var obj = {name: "Alice"}
+    obj.identity = {self: obj}
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify({name: "Alice", identity: {self: "[Circular ~]"}}))
+  })
+
+  it("must stringify circular objects deeper", function() {
+    var obj = {name: "Alice", child: {name: "Bob"}}
+    obj.child.self = obj.child
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice",
+      child: {name: "Bob", self: "[Circular ~.child]"}
+    }))
+  })
+
+  it("must stringify circular objects deeper with intermediaries", function() {
+    var obj = {name: "Alice", child: {name: "Bob"}}
+    obj.child.identity = {self: obj.child}
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice",
+      child: {name: "Bob", identity: {self: "[Circular ~.child]"}}
+    }))
+  })
+
+  it("must stringify circular objects in an array", function() {
+    var obj = {name: "Alice"}
+    obj.self = [obj, obj]
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice", self: ["[Circular ~]", "[Circular ~]"]
+    }))
+  })
+
+  it("must stringify circular objects deeper in an array", function() {
+    var obj = {name: "Alice", children: [{name: "Bob"}, {name: "Eve"}]}
+    obj.children[0].self = obj.children[0]
+    obj.children[1].self = obj.children[1]
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice",
+      children: [
+        {name: "Bob", self: "[Circular ~.children.0]"},
+        {name: "Eve", self: "[Circular ~.children.1]"}
+      ]
+    }))
+  })
+
+  it("must stringify circular arrays", function() {
+    var obj = []
+    obj.push(obj)
+    obj.push(obj)
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify(["[Circular ~]", "[Circular ~]"]))
+  })
+
+  it("must stringify circular arrays with intermediaries", function() {
+    var obj = []
+    obj.push({name: "Alice", self: obj})
+    obj.push({name: "Bob", self: obj})
+
+    stringify(obj, null, 2).must.eql(jsonify([
+      {name: "Alice", self: "[Circular ~]"},
+      {name: "Bob", self: "[Circular ~]"}
+    ]))
+  })
+
+  it("must stringify repeated objects in objects", function() {
+    var obj = {}
+    var alice = {name: "Alice"}
+    obj.alice1 = alice
+    obj.alice2 = alice
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      alice1: {name: "Alice"},
+      alice2: {name: "Alice"}
+    }))
+  })
+
+  it("must stringify repeated objects in arrays", function() {
+    var alice = {name: "Alice"}
+    var obj = [alice, alice]
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify([{name: "Alice"}, {name: "Alice"}]))
+  })
+
+  it("must call given decycler and use its output", function() {
+    var obj = {}
+    obj.a = obj
+    obj.b = obj
+
+    var decycle = Sinon.spy(function() { return decycle.callCount })
+    var json = stringify(obj, null, 2, decycle)
+    json.must.eql(jsonify({a: 1, b: 2}, null, 2))
+
+    decycle.callCount.must.equal(2)
+    decycle.thisValues[0].must.equal(obj)
+    decycle.args[0][0].must.equal("a")
+    decycle.args[0][1].must.equal(obj)
+    decycle.thisValues[1].must.equal(obj)
+    decycle.args[1][0].must.equal("b")
+    decycle.args[1][1].must.equal(obj)
+  })
+
+  it("must call replacer and use its output", function() {
+    var obj = {name: "Alice", child: {name: "Bob"}}
+
+    var replacer = Sinon.spy(bangString)
+    var json = stringify(obj, replacer, 2)
+    json.must.eql(jsonify({name: "Alice!", child: {name: "Bob!"}}))
+
+    replacer.callCount.must.equal(4)
+    replacer.args[0][0].must.equal("")
+    replacer.args[0][1].must.equal(obj)
+    replacer.thisValues[1].must.equal(obj)
+    replacer.args[1][0].must.equal("name")
+    replacer.args[1][1].must.equal("Alice")
+    replacer.thisValues[2].must.equal(obj)
+    replacer.args[2][0].must.equal("child")
+    replacer.args[2][1].must.equal(obj.child)
+    replacer.thisValues[3].must.equal(obj.child)
+    replacer.args[3][0].must.equal("name")
+    replacer.args[3][1].must.equal("Bob")
+  })
+
+  it("must call replacer after describing circular references", function() {
+    var obj = {name: "Alice"}
+    obj.self = obj
+
+    var replacer = Sinon.spy(bangString)
+    var json = stringify(obj, replacer, 2)
+    json.must.eql(jsonify({name: "Alice!", self: "[Circular ~]!"}))
+
+    replacer.callCount.must.equal(3)
+    replacer.args[0][0].must.equal("")
+    replacer.args[0][1].must.equal(obj)
+    replacer.thisValues[1].must.equal(obj)
+    replacer.args[1][0].must.equal("name")
+    replacer.args[1][1].must.equal("Alice")
+    replacer.thisValues[2].must.equal(obj)
+    replacer.args[2][0].must.equal("self")
+    replacer.args[2][1].must.equal("[Circular ~]")
+  })
+
+  it("must call given decycler and use its output for nested objects",
+    function() {
+    var obj = {}
+    obj.a = obj
+    obj.b = {self: obj}
+
+    var decycle = Sinon.spy(function() { return decycle.callCount })
+    var json = stringify(obj, null, 2, decycle)
+    json.must.eql(jsonify({a: 1, b: {self: 2}}))
+
+    decycle.callCount.must.equal(2)
+    decycle.args[0][0].must.equal("a")
+    decycle.args[0][1].must.equal(obj)
+    decycle.args[1][0].must.equal("self")
+    decycle.args[1][1].must.equal(obj)
+  })
+
+  it("must use decycler's output when it returned null", function() {
+    var obj = {a: "b"}
+    obj.self = obj
+    obj.selves = [obj, obj]
+
+    function decycle() { return null }
+    stringify(obj, null, 2, decycle).must.eql(jsonify({
+      a: "b",
+      self: null,
+      selves: [null, null]
+    }))
+  })
+
+  it("must use decycler's output when it returned undefined", function() {
+    var obj = {a: "b"}
+    obj.self = obj
+    obj.selves = [obj, obj]
+
+    function decycle() {}
+    stringify(obj, null, 2, decycle).must.eql(jsonify({
+      a: "b",
+      selves: [null, null]
+    }))
+  })
+
+  it("must throw given a decycler that returns a cycle", function() {
+    var obj = {}
+    obj.self = obj
+    var err
+    function identity(key, value) { return value }
+    try { stringify(obj, null, 2, identity) } catch (ex) { err = ex }
+    err.must.be.an.instanceof(TypeError)
+  })
+
+  describe(".getSerialize", function() {
+    it("must stringify circular objects", function() {
+      var obj = {a: "b"}
+      obj.circularRef = obj
+      obj.list = [obj, obj]
+
+      var json = JSON.stringify(obj, stringify.getSerialize(), 2)
+      json.must.eql(jsonify({
+        "a": "b",
+        "circularRef": "[Circular ~]",
+        "list": ["[Circular ~]", "[Circular ~]"]
+      }))
+    })
+
+    // This is the behavior as of Mar 3, 2015.
+    // The serializer function keeps state inside the returned function and
+    // so far I'm not sure how to not do that. JSON.stringify's replacer is not
+    // called _after_ serialization.
+    xit("must return a function that could be called twice", function() {
+      var obj = {name: "Alice"}
+      obj.self = obj
+
+      var json
+      var serializer = stringify.getSerialize()
+
+      json = JSON.stringify(obj, serializer, 2)
+      json.must.eql(jsonify({name: "Alice", self: "[Circular ~]"}))
+
+      json = JSON.stringify(obj, serializer, 2)
+      json.must.eql(jsonify({name: "Alice", self: "[Circular ~]"}))
+    })
+  })
+})
+
+function bangString(key, value) {
+  return typeof value == "string" ? value + "!" : value
+}

package/node_modules/kitx/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jackson Tian
+
+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/kitx/README.md

@@ -0,0 +1,35 @@
+# kitx
+
+A Node.js toolkit.
+
+[![NPM version][npm-image]][npm-url]
+[![Node.js CI](https://github.com/JacksonTian/kitx/actions/workflows/node.js.yml/badge.svg)](https://github.com/JacksonTian/kitx/actions/workflows/node.js.yml)
+[![codecov](https://codecov.io/gh/JacksonTian/kitx/branch/master/graph/badge.svg?token=XqdL3E9piR)](https://codecov.io/gh/JacksonTian/kitx)
+[![npm download][download-image]][download-url]
+
+[npm-image]: https://img.shields.io/npm/v/kitx.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/kitx
+[download-image]: https://img.shields.io/npm/dm/kitx.svg?style=flat-square
+[download-url]: https://npmjs.org/package/kitx
+
+## Installation
+
+```sh
+npm install kitx --save
+```
+
+## Usage
+
+Require it:
+
+```js
+const kitx = require('kitx');
+```
+
+## API
+
+See [API docs](http://doxmate.cool/JacksonTian/kitx/api.html).
+
+## License
+
+The MIT license.

package/node_modules/kitx/lib/index.d.ts

@@ -0,0 +1,45 @@
+import { Readable } from 'stream';
+
+interface Hash {
+    (data: string | Buffer, encoding?: string | undefined): string | Buffer;
+}
+
+interface Hmac {
+    (data: string | Buffer, key: string | Buffer, encoding?: string | undefined): string | Buffer;
+}
+
+export function createHash(algorithm: string): Hash;
+
+export function createHmac(algorithm: string): Hmac;
+
+export function encode(str: string, encoding: string): Buffer;
+
+export function getIPv4(): string;
+
+export function getMac(): string;
+
+export function getYYYYMMDD(date: Date): string;
+
+export function loadJSONSync(filename: string): any;
+
+export function makeHasher(algorithm: string): Hash;
+
+export function makeNonce(): string;
+
+export function md5(data: string | Buffer, encoding?: string | undefined): string;
+
+export function pad2(num: number): string;
+
+export function pad3(num: number): string;
+
+export function random(min: number, max: number): number;
+
+export function sha1(data: string | Buffer, key: string, encoding?: string | undefined): string | Buffer;
+
+export function sleep(ms: number): Promise<void>;
+
+export function readAll(readable: Readable): Promise<Buffer>;
+
+export function encrypt(data: string | Buffer, inputEncoding?: string | undefined, outputEncoding?: string | undefined) : string | Buffer;
+
+export function decrypt(encrypt: string | Buffer, inputEncoding?: string | undefined, outputEncoding?: string | undefined) : string | Buffer;

package/node_modules/kitx/lib/index.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const crypto = require('crypto');
+
+/**
+ * Load *.json file synchronous. Don't use require('*.json')
+ * to load *.json files, it will cached in process.
+ * @param {String} filename absolute file path
+ * @return {Object} a parsed object
+ */
+exports.loadJSONSync = function (filename) {
+  // strip BOM
+  var content = fs.readFileSync(filename, 'utf8');
+  if (content.charCodeAt(0) === 0xFEFF) {
+    content = content.slice(1);
+  }
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    err.message = filename + ': ' + err.message;
+    throw err;
+  }
+};
+
+/**
+ * Encoding a string to Buffer safely
+ * @param {String} str string.
+ * @param {String} encoding. optional.
+ * @return {Buffer} encoded buffer
+ */
+exports.encode = function (str, encoding) {
+  if (typeof str !== 'string') {
+    str = '' + str;
+  }
+
+  return Buffer.from(str, encoding);
+};
+
+/**
+ * Generate a haser with specfied algorithm
+ * @param {String} algorithm can be md5, etc.
+ * @return {Function} a haser with specfied algorithm
+ */
+exports.makeHasher = function (algorithm) {
+  return function (data, encoding) {
+    var shasum = crypto.createHash(algorithm);
+    shasum.update(data);
+    return shasum.digest(encoding);
+  };
+};
+
+exports.createHash = exports.makeHasher;
+
+/**
+ * Get md5 hash digests of data
+ * @param {String|Buffer} data data.
+ * @param {String} encoding optional. can be 'hex', 'binary', 'base64'.
+ * @return {String|Buffer} if no encoding is provided, a buffer is returned.
+ */
+exports.md5 = exports.makeHasher('md5');
+
+/**
+ * Get sha1 hash digests of data
+ * @param {String|Buffer} data data.
+ * @param {String} key the key.
+ * @param {String} encoding optionnal. can be 'hex', 'binary', 'base64'.
+ * @return {String|Buffer} if no encoding is provided, a buffer is returned.
+ */
+exports.createHmac = function (algorithm) {
+  return function (data, key, encoding) {
+    return crypto.createHmac(algorithm, key).update(data).digest(encoding);
+  };
+};
+
+/**
+ * Get sha1 hash digests of data
+ * @param {String|Buffer} data data.
+ * @param {String} key the key.
+ * @param {String} encoding optionnal. can be 'hex', 'binary', 'base64'.
+ * @return {String|Buffer} if no encoding is provided, a buffer is returned.
+ */
+exports.sha1 = exports.createHmac('sha1');
+
+/**
+ * Get a random value in a range
+ * @param {Number} min range start.
+ * @param {Number} max range end.
+ */
+exports.random = function (min, max) {
+  return Math.floor(min + Math.random() * (max - min));
+};
+
+/**
+ * Generate a nonce string
+ * @return {String} a nonce string.
+ */
+exports.makeNonce = (function () {
+  var counter = 0;
+  var last;
+  const machine = os.hostname();
+  const pid = process.pid;
+
+  return function () {
+    var val = Math.floor(Math.random() * 1000000000000);
+    if (val === last) {
+      counter++;
+    } else {
+      counter = 0;
+    }
+
+    last = val;
+
+    var uid = `${machine}${pid}${val}${counter}`;
+    return exports.md5(uid, 'hex');
+  };
+}());
+
+/**
+ * Pad a number as \d\d format
+ * @param {Number} num a number that less than 100.
+ * @return {String} if number less than 10, pad with 0,
+ *  otherwise, returns string of number.
+ */
+exports.pad2 = function (num) {
+  if (num < 10) {
+    return '0' + num;
+  }
+  return '' + num;
+};
+
+/**
+ * Pad a number as \d\d\d format
+ * @param {Number} num a number that less than 1000.
+ * @return {String} if number less than 100, pad with 0,
+ *  otherwise, returns string of number.
+ */
+exports.pad3 = function (num) {
+  if (num < 10) {
+    return '00' + num;
+  } else if (num < 100) {
+    return '0' + num;
+  }
+  return '' + num;
+};
+
+/**
+ * Return the YYYYMMDD format of a date.
+ * @param {Date} date a Date object.
+ * @return {String} the YYYYMMDD format.
+ */
+exports.getYYYYMMDD = function (date) {
+  var YYYY = date.getFullYear();
+  var MM = exports.pad2(date.getMonth() + 1);
+  var DD = exports.pad2(date.getDate());
+  return '' + YYYY + MM + DD;
+};
+
+/**
+ * sleep a while.
+ * @param {Number} in milliseconds
+ * @return {Promise} a Promise
+ */
+exports.sleep = function (ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+
+/**
+ * Get the IPv4 address
+ * @return {String} the IPv4 address, or empty string
+ */
+exports.getIPv4 = function () {
+  var interfaces = os.networkInterfaces();
+  var keys = Object.keys(interfaces);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var addresses = interfaces[key];
+    for (var j = 0; j < addresses.length; j++) {
+      var item = addresses[j];
+      if (!item.internal && item.family === 'IPv4') {
+        return item.address;
+      }
+    }
+  }
+
+  // without non-internal address
+  return '';
+};
+
+/**
+ * Get the Mac address
+ * @return {String} the Mac address
+ */
+exports.getMac = function () {
+  var interfaces = os.networkInterfaces();
+  var keys = Object.keys(interfaces);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var addresses = interfaces[key];
+    for (var j = 0; j < addresses.length; j++) {
+      var item = addresses[j];
+      if (!item.internal && item.family === 'IPv4') {
+        return item.mac;
+      }
+    }
+  }
+
+  // without non-internal address
+  return '00:00:00:00:00:00';
+};
+
+/**
+ * Read all bytes from a readable
+ * @return {Readable} the readable stream
+ * @return {Promise} a Promise with all bytes
+ */
+exports.readAll = function (readable) {
+  return new Promise((resolve, reject) => {
+    var onError, onData, onEnd;
+    var cleanup = function (err) {
+      // cleanup
+      readable.removeListener('error', onError);
+      readable.removeListener('data', onData);
+      readable.removeListener('end', onEnd);
+    };
+
+    var bufs = [];
+    var size = 0;
+
+    onData = function (buf) {
+      bufs.push(buf);
+      size += buf.length;
+    };
+
+    onError = function (err) {
+      cleanup();
+      reject(err);
+    };
+
+    onEnd = function () {
+      cleanup();
+      resolve(Buffer.concat(bufs, size));
+    };
+
+    readable.on('error', onError);
+    readable.on('data', onData);
+    readable.on('end', onEnd);
+  });
+};
+
+class SimpleCryptoHelper {
+  constructor(algorithm, key, iv) {
+    this.algorithm = algorithm;
+    this.key = key;
+    this.iv = iv;
+  }
+
+  encrypt(data, inputEncoding, outputEncoding) {
+    const cipher = crypto.createCipheriv(this.algorithm, this.key, this.iv);
+    let output = cipher.update(data, inputEncoding, outputEncoding);
+    output += cipher.final(outputEncoding);
+    return output;
+  }
+
+  decrypt(encrypted, inputEncoding, outputEncoding) {
+    const decipher = crypto.createDecipheriv(this.algorithm, this.key, this.iv);
+    let output = decipher.update(encrypted, inputEncoding, outputEncoding);
+    output += decipher.final(outputEncoding);
+    return output;
+  }
+}
+
+// a simple helper for AES-192
+const helper = new SimpleCryptoHelper(
+  'aes-192-cbc',
+  Buffer.from('keykeykeykeykeykeykeykey'), // 24 bytes, 192 bits
+  Buffer.from('abcdefghijklmnop') // 16 bytes
+);
+
+exports.encrypt = function (data, inputEncoding, outputEncoding) {
+  return helper.encrypt(data, inputEncoding, outputEncoding);
+}
+
+exports.decrypt = function (encrypted, inputEncoding, outputEncoding) {
+  return helper.decrypt(encrypted, inputEncoding, outputEncoding);
+}

package/node_modules/kitx/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "kitx",
+  "version": "2.2.0",
+  "description": "toolkit",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "lint": "eslint --fix lib test",
+    "test": "mocha --reporter spec --timeout 3000 test/*.test.js",
+    "test-cov": "nyc -r=lcov -r=html -r=text -r=json mocha -t 3000 -R spec test/*.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JacksonTian/kitx.git"
+  },
+  "author": "Jackson Tian",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/JacksonTian/kitx/issues"
+  },
+  "homepage": "https://github.com/JacksonTian/kitx#readme",
+  "keywords": [
+    "toolkit",
+    "kit"
+  ],
+  "dependencies": {
+    "@types/node": "^22.5.4"
+  },
+  "devDependencies": {
+    "eslint": "^9.0.0",
+    "expect.js": "^0.3.1",
+    "mocha": "^10.0.0",
+    "nyc": "^17.0.0"
+  },
+  "files": [
+    "lib"
+  ]
+}