d

bigdata/node_modules/.bin/element-theme

+../_element-theme@2.0.1@element-theme/bin/element-theme
\ No newline at end of file

bigdata/node_modules/.bin/et

+../_element-theme@2.0.1@element-theme/bin/element-theme
\ No newline at end of file

bigdata/node_modules/.bin/pinyin

+../_pinyin@2.9.0@pinyin/bin/pinyin
\ No newline at end of file

bigdata/node_modules/.bin/sequelize

+../_sequelize-cli@4.1.1@sequelize-cli/lib/sequelize
\ No newline at end of file

bigdata/node_modules/.bin/uuid

+../_uuid@3.3.3@uuid/bin/uuid
\ No newline at end of file

bigdata/node_modules/.recently_updates.txt

+Recently updated (since 2019-11-12)
+  Today:
+    → ejs@^2.5.8(2.7.3) (10:00:13)
+    → @alicloud/pop-core@1.7.7 › httpx@2.2.2 › @types/node@^12.0.2(12.12.9) (04:49:56)
+  2019-11-17
+    → @alicloud/pop-core@1.7.7 › xml2js@0.4.22 › util.promisify@1.0.0 › object.getownpropertydescriptors@2.0.3 › es-abstract@1.16.0 › has-symbols@^1.0.0(1.0.1) (08:01:00)
+  2019-11-15
+    → mongoose@^5.3.6(5.7.11) (00:00:40)
+  2019-11-14
+    → element-theme@2.0.1 › gulp-autoprefixer@4.1.0 › autoprefixer@7.2.6 › caniuse-lite@^1.0.30000805(1.0.30001010) (15:32:35)
+  2019-11-12
+    → body-parser@1.19.0 › type-is@1.6.18 › mime-types@~2.1.24(2.1.25) (22:18:16)
+    → element-theme@2.0.1 › run-sequence@1.2.2 › chalk@3.0.0 › ansi-styles@^4.1.0(4.2.0) (19:20:05)

bigdata/node_modules/@alicloud/pop-core

+../_@alicloud_pop-core@1.7.7@@alicloud/pop-core
\ No newline at end of file

bigdata/node_modules/@types/color-name

+../_@types_color-name@1.1.1@@types/color-name
\ No newline at end of file

bigdata/node_modules/@types/geojson

+../_@types_geojson@1.0.6@@types/geojson
\ No newline at end of file

bigdata/node_modules/@types/node

+../_@types_node@12.12.9@@types/node
\ No newline at end of file

bigdata/node_modules/MD5

+_MD5@1.3.0@MD5
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/CHANGELOG.md

+## 1.0.2 (2017-01-16)
+
+Feature:
+
+- 返回出错的结果，挂载到返回error的data对象上，err.data = resData
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/README.md

+# @alicloud/pop-core
+
+The core SDK of POP API.
+
+[![NPM version][npm-image]][npm-url]
+[![build status][travis-image]][travis-url]
+[![codecov][cov-image]][cov-url]
+
+[npm-image]: https://img.shields.io/npm/v/@alicloud/pop-core.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@alicloud/pop-core
+[travis-image]: https://img.shields.io/travis/aliyun/openapi-core-nodejs-sdk/master.svg?style=flat-square
+[travis-url]: https://travis-ci.org/aliyun/openapi-core-nodejs-sdk
+[cov-image]: https://codecov.io/gh/aliyun/openapi-core-nodejs-sdk/branch/master/graph/badge.svg
+[cov-url]: https://codecov.io/gh/aliyun/openapi-core-nodejs-sdk
+
+## Installation
+
+Install it and write into package.json dependences.
+
+```sh
+$ npm install @alicloud/pop-core -S
+```
+
+## Prerequisite
+
+Node.js >= 8.x
+
+### Notes
+
+You must know your `AK`(`accessKeyId/accessKeySecret`), and the cloud product's `endpoint` and `apiVersion`.
+
+For example, The ECS OpenAPI(https://help.aliyun.com/document_detail/25490.html), the API version is `2014-05-26`.
+
+And the endpoint list can be found at [here](https://help.aliyun.com/document_detail/25489.html), the center endpoint is ecs.aliyuncs.com. Add http protocol `http` or `https`, should be `http://ecs.aliyuncs.com/`.
+
+
+## Online Demo
+
+**[API Explorer](https://api.aliyun.com)** provides the ability to call the cloud product OpenAPI online, and dynamically generate SDK Example code and quick retrieval interface, which can significantly reduce the difficulty of using the cloud API. **It is highly recommended**.
+
+<a href="https://api.aliyun.com" target="api_explorer">
+  <img src="https://img.alicdn.com/tfs/TB12GX6zW6qK1RjSZFmXXX0PFXa-744-122.png" width="180" />
+</a>
+
+
+## Usage
+
+The RPC style client:
+
+```js
+var RPCClient = require('@alicloud/pop-core').RPCClient;
+
+var client = new RPCClient({
+  accessKeyId: '<accessKeyId>',
+  accessKeySecret: '<accessKeySecret>',
+  endpoint: '<endpoint>',
+  apiVersion: '<apiVersion>'
+});
+
+// => returns Promise
+client.request(action, params);
+// co/yield, async/await
+
+// options
+client.request(action, params, {
+  timeout: 3000, // default 3000 ms
+  formatAction: true, // default true, format the action to Action
+  formatParams: true, // default true, format the parameter name to first letter upper case
+  method: 'GET', // set the http method, default is GET
+  headers: {}, // set the http request headers
+});
+```
+
+The ROA style client:
+
+```js
+var ROAClient = require('@alicloud/pop-core').ROAClient;
+
+var client = new ROAClient({
+  accessKeyId: '<accessKeyId>',
+  accessKeySecret: '<secretAccessKey>',
+  endpoint: '<endpoint>',
+  apiVersion: '<apiVersion>'
+});
+
+// => returns Promise
+// request(HTTPMethod, uriPath, queries, body, headers, options);
+// options => {timeout}
+client.request('GET', '/regions');
+// co/yield, async/await
+```
+
+### Custom opts
+
+We offer two ways to customize request opts.
+
+One way is passing opts through the Client constructor. You should treat opts passed through the constructor as default custom opts, because all requests will use this opts.
+
+```js
+var client = new RPCClient({
+  accessKeyId: '<accessKeyId>',
+  accessKeySecret: '<accessKeySecret>',
+  endpoint: '<endpoint>',
+  apiVersion: '<apiVersion>',
+  opts: {
+    timeout: 3000
+  }
+});
+```
+
+Another way is passing opts through the function's parameter. You should use this way when you want to just pass opts in specific functions.
+
+```js
+client.request(action, params, {
+  timeout: 3000
+});
+```
+
+When both ways are used, opts will be merged. But for the opt with the same key, the opts provided by the function parameter overrides the opts provided by the constructor.
+
+### Http Proxy Support
+
+```js
+var tunnel = require('tunnel-agent');
+
+var RPCClient = require('@alicloud/pop-core').RPCClient;
+
+var client = new RPCClient({
+  accessKeyId: '<accessKeyId>',
+  accessKeySecret: '<accessKeySecret>',
+  endpoint: '<endpoint>',
+  apiVersion: '<apiVersion>'
+});
+
+
+client.request(action, params, {
+  agent: tunnel.httpOverHttp({
+    proxy: {
+      host: 'host',
+      port: port
+    }
+  });
+});
+```
+
+## License
+The MIT License

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/index.js

+'use strict';
+
+module.exports = require('./lib/rpc');
+module.exports.ROAClient = require('./lib/roa');
+module.exports.RPCClient = require('./lib/rpc');

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/lib/helper.js

+'use strict';
+
+const os = require('os');
+
+const pkg = require('../package.json');
+
+exports.DEFAULT_UA = `AlibabaCloud (${os.platform()}; ${os.arch()}) ` +
+  `Node.js/${process.version} Core/${pkg.version}`;
+exports.DEFAULT_CLIENT = `Node.js(${process.version}), ${pkg.name}: ${pkg.version}`;

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/lib/roa.js

+'use strict';
+
+const assert = require('assert');
+const url = require('url');
+const querystring = require('querystring');
+
+const kitx = require('kitx');
+const httpx = require('httpx');
+const xml2js = require('xml2js');
+const JSON = require('json-bigint');
+const debug = require('debug')('roa');
+
+const helper = require('./helper');
+
+function filter(value) {
+  return value.replace(/[\t\n\r\f]/g, ' ');
+}
+
+function keyLowerify(headers) {
+  const keys = Object.keys(headers);
+  const newHeaders = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    newHeaders[key.toLowerCase()] = headers[key];
+  }
+  return newHeaders;
+}
+
+function getCanonicalizedHeaders(headers) {
+  const prefix = 'x-acs-';
+  const keys = Object.keys(headers);
+
+  const canonicalizedKeys = [];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key.startsWith(prefix)) {
+      canonicalizedKeys.push(key);
+    }
+  }
+
+  canonicalizedKeys.sort();
+
+  var result = '';
+  for (let i = 0; i < canonicalizedKeys.length; i++) {
+    const key = canonicalizedKeys[i];
+    result += `${key}:${filter(headers[key]).trim()}\n`;
+  }
+
+  return result;
+}
+
+function getCanonicalizedResource(uriPattern, query) {
+  const keys = Object.keys(query).sort();
+
+  if (keys.length === 0) {
+    return uriPattern;
+  }
+
+  var result = [];
+  for (var i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    result.push(`${key}=${query[key]}`);
+  }
+
+  return `${uriPattern}?${result.join('&')}`;
+}
+
+function buildStringToSign(method, uriPattern, headers, query) {
+  const accept = headers['accept'];
+  const contentMD5 = headers['content-md5'] || '';
+  const contentType = headers['content-type'] || '';
+  const date = headers['date'] || '';
+
+  const header = `${method}\n${accept}\n${contentMD5}\n${contentType}\n${date}\n`;
+
+  const canonicalizedHeaders = getCanonicalizedHeaders(headers);
+  const canonicalizedResource = getCanonicalizedResource(uriPattern, query);
+
+  return `${header}${canonicalizedHeaders}${canonicalizedResource}`;
+}
+
+function parseXML(xml) {
+  const parser = new xml2js.Parser({
+    // explicitArray: false
+  });
+  return new Promise((resolve, reject) => {
+    parser.parseString(xml, (err, result) => {
+      if (err) {
+        return reject(err);
+      }
+
+      resolve(result);
+    });
+  });
+}
+
+class ACSError extends Error {
+  constructor(err) {
+    const message = err.Message[0];
+    const code = err.Code[0];
+    const hostid = err.HostId[0];
+    const requestid = err.RequestId[0];
+    super(`${message} hostid: ${hostid}, requestid: ${requestid}`);
+    this.code = code;
+  }
+}
+
+class ROAClient {
+  constructor(config) {
+    assert(config, 'must pass "config"');
+    assert(config.endpoint, 'must pass "config.endpoint"');
+    if (!config.endpoint.startsWith('https://') &&
+      !config.endpoint.startsWith('http://')) {
+      throw new Error(`"config.endpoint" must starts with 'https://' or 'http://'.`);
+    }
+    assert(config.apiVersion, 'must pass "config.apiVersion"');
+    assert(config.accessKeyId, 'must pass "config.accessKeyId"');
+    assert(config.accessKeySecret, 'must pass "config.accessKeySecret"');
+
+    this.endpoint = config.endpoint;
+
+    this.apiVersion = config.apiVersion;
+    this.accessKeyId = config.accessKeyId;
+    this.accessKeySecret = config.accessKeySecret;
+    this.securityToken = config.securityToken;
+    this.host = url.parse(this.endpoint).hostname;
+    this.opts = config.opts;
+    var httpModule = this.endpoint.startsWith('https://') ? require('https') : require('http');
+    this.keepAliveAgent = new httpModule.Agent({
+      keepAlive: true,
+      keepAliveMsecs: 3000
+    });
+  }
+
+  buildHeaders() {
+    const now = new Date();
+    var defaultHeaders = {
+      accept: 'application/json',
+      date: now.toGMTString(),
+      host: this.host,
+      'x-acs-signature-nonce': kitx.makeNonce(),
+      'x-acs-signature-method': 'HMAC-SHA1',
+      'x-acs-signature-version': '1.0',
+      'x-acs-version': this.apiVersion,
+      'user-agent': helper.DEFAULT_UA,
+      'x-sdk-client': helper.DEFAULT_CLIENT
+    };
+    if (this.securityToken) {
+      defaultHeaders['x-acs-accesskey-id'] = this.accessKeyId;
+      defaultHeaders['x-acs-security-token'] = this.securityToken;
+    }
+    return defaultHeaders;
+  }
+
+  signature(stringToSign) {
+    const utf8Buff = Buffer.from(stringToSign, 'utf8');
+
+    return kitx.sha1(utf8Buff, this.accessKeySecret, 'base64');
+  }
+
+  buildAuthorization(stringToSign) {
+    return `acs ${this.accessKeyId}:${this.signature(stringToSign)}`;
+  }
+
+  request(method, uriPattern, query = {}, body = '', headers = {}, opts = {}) {
+    var postBody = null;
+
+    var mixHeaders = Object.assign(this.buildHeaders(), keyLowerify(headers));
+    if (body) {
+      postBody = Buffer.from(body, 'utf8');
+      mixHeaders['content-md5'] = kitx.md5(postBody, 'base64');
+      mixHeaders['content-length'] = postBody.length;
+    }
+
+    var url = `${this.endpoint}${uriPattern}`;
+    if (Object.keys(query).length) {
+      url += `?${querystring.stringify(query)}`;
+    }
+
+    const stringToSign = buildStringToSign(method, uriPattern, mixHeaders, query);
+    debug('stringToSign: %s', stringToSign);
+    mixHeaders['authorization'] = this.buildAuthorization(stringToSign);
+
+    const options = Object.assign({
+      method,
+      agent: this.keepAliveAgent,
+      headers: mixHeaders,
+      data: postBody
+    }, this.opts, opts);
+
+    return httpx.request(url, options).then((response) => {
+      return httpx.read(response, 'utf8').then((body) => {
+        // Retrun raw body
+        if (opts.rawBody) {
+          return body;
+        }
+
+        const contentType = response.headers['content-type'] || '';
+        // JSON
+        if (contentType.startsWith('application/json')) {
+          const statusCode = response.statusCode;
+          if (statusCode === 204) {
+            return body;
+          }
+
+          var result;
+          try {
+            result = JSON.parse(body);
+          } catch (err) {
+            err.name = 'FormatError';
+            err.message = 'parse response to json error';
+            err.body = body;
+            throw err;
+          }
+
+          if (statusCode >= 400) {
+            const errorMessage = result.Message || result.errorMsg || '';
+            const errorCode = result.Code || result.errorCode || '';
+            const requestId = result.RequestId || '';
+            var err = new Error(`code: ${statusCode}, ${errorMessage}, requestid: ${requestId}`);
+            err.name = `${errorCode}Error`;
+            err.statusCode = statusCode;
+            err.result = result;
+            err.code = errorCode;
+            throw err;
+          }
+
+          return result;
+        }
+
+        if (contentType.startsWith('text/xml')) {
+          return parseXML(body).then((result) => {
+            if (result.Error) {
+              throw new ACSError(result.Error);
+            }
+
+            return result;
+          });
+        }
+
+        return body;
+      });
+    });
+  }
+
+  put(path, query, body, headers, options) {
+    return this.request('PUT', path, query, body, headers, options);
+  }
+
+  post(path, query, body, headers, options) {
+    return this.request('POST', path, query, body, headers, options);
+  }
+
+  get(path, query, headers, options) {
+    return this.request('GET', path, query, '', headers, options);
+  }
+
+  delete(path, query, headers, options) {
+    return this.request('DELETE', path, query, '', headers, options);
+  }
+}
+
+module.exports = ROAClient;

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/lib/rpc.d.ts

+// Type definitions for [~THE LIBRARY NAME~] [~OPTIONAL VERSION NUMBER~]
+// Project: [~THE PROJECT NAME~]
+// Definitions by: [~YOUR NAME~] <[~A URL FOR YOU~]>
+
+/*~ This is the module template file for class modules.
+ *~ You should rename it to index.d.ts and place it in a folder with the same name as the module.
+ *~ For example, if you were writing a file for "super-greeter", this
+ *~ file should be 'super-greeter/index.d.ts'
+ */
+
+/*~ Note that ES6 modules cannot directly export class objects.
+ *~ This file should be imported using the CommonJS-style:
+ *~   import x = require('someLibrary');
+ *~
+ *~ Refer to the documentation to understand common
+ *~ workarounds for this limitation of ES6 modules.
+ */
+
+
+/*~ This declaration specifies that the class constructor function
+ *~ is the exported object from the file
+ */
+export = RPCClient;
+
+/*~ Write your module's methods and properties in this class */
+declare class RPCClient {
+    constructor(config: RPCClient.Config);
+
+    request<T>(action: String, params: Object, options?: Object): Promise<T>;
+}
+
+/*~ If you want to expose types from your module as well, you can
+ *~ place them in this block.
+ */
+declare namespace RPCClient {
+    export interface Config {
+        endpoint: string;
+        apiVersion: string;
+        accessKeyId: string;
+        accessKeySecret: string;
+        codes?: (string | number)[];
+        opts?: object;
+    }
+}

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/lib/rpc.js

+'use strict';
+
+const assert = require('assert');
+
+const httpx = require('httpx');
+const kitx = require('kitx');
+const JSON = require('json-bigint');
+
+const helper = require('./helper');
+
+function firstLetterUpper(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+
+function formatParams(params) {
+  var keys = Object.keys(params);
+  var newParams = {};
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    newParams[firstLetterUpper(key)] = params[key];
+  }
+  return newParams;
+}
+
+
+function timestamp() {
+  var date = new Date();
+  var YYYY = date.getUTCFullYear();
+  var MM = kitx.pad2(date.getUTCMonth() + 1);
+  var DD = kitx.pad2(date.getUTCDate());
+  var HH = kitx.pad2(date.getUTCHours());
+  var mm = kitx.pad2(date.getUTCMinutes());
+  var ss = kitx.pad2(date.getUTCSeconds());
+  // 删除掉毫秒部分
+  return `${YYYY}-${MM}-${DD}T${HH}:${mm}:${ss}Z`;
+}
+
+function encode(str) {
+  var result = encodeURIComponent(str);
+
+  return result.replace(/\!/g, '%21')
+   .replace(/\'/g, '%27')
+   .replace(/\(/g, '%28')
+   .replace(/\)/g, '%29')
+   .replace(/\*/g, '%2A');
+}
+
+function replaceRepeatList(target, key, repeat) {
+  for (var i = 0; i < repeat.length; i++) {
+    var item = repeat[i];
+
+    if (item && typeof item === 'object') {
+      const keys = Object.keys(item);
+      for (var j = 0; j < keys.length; j++) {
+        target[`${key}.${i + 1}.${keys[j]}`] = item[keys[j]];
+      }
+    } else {
+      target[`${key}.${i + 1}`] = item;
+    }
+  }
+}
+
+function flatParams(params) {
+  var target = {};
+  var keys = Object.keys(params);
+  for (let i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = params[key];
+    if (Array.isArray(value)) {
+      replaceRepeatList(target, key, value);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+
+function normalize(params) {
+  var list = [];
+  var flated = flatParams(params);
+  var keys = Object.keys(flated).sort();
+  for (let i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = flated[key];
+    list.push([encode(key), encode(value)]); //push []
+  }
+  return list;
+}
+
+function canonicalize(normalized) {
+  var fields = [];
+  for (var i = 0; i < normalized.length; i++) {
+    var [key, value] = normalized[i];
+    fields.push(key + '=' + value);
+  }
+  return fields.join('&');
+}
+
+class RPCClient {
+  constructor(config, verbose) {
+    assert(config, 'must pass "config"');
+    assert(config.endpoint, 'must pass "config.endpoint"');
+    if (!config.endpoint.startsWith('https://') &&
+      !config.endpoint.startsWith('http://')) {
+      throw new Error(`"config.endpoint" must starts with 'https://' or 'http://'.`);
+    }
+    assert(config.apiVersion, 'must pass "config.apiVersion"');
+    assert(config.accessKeyId, 'must pass "config.accessKeyId"');
+    var accessKeySecret = config.secretAccessKey || config.accessKeySecret;
+    assert(accessKeySecret, 'must pass "config.accessKeySecret"');
+
+    if (config.endpoint.endsWith('/')) {
+      config.endpoint = config.endpoint.slice(0, -1);
+    }
+
+    this.endpoint = config.endpoint;
+    this.apiVersion = config.apiVersion;
+    this.accessKeyId = config.accessKeyId;
+    this.accessKeySecret = accessKeySecret;
+    this.securityToken = config.securityToken;
+    this.verbose = verbose === true;
+    // 非 codes 里的值，将抛出异常
+    this.codes = new Set([200, '200', 'OK', 'Success']);
+    if (config.codes) {
+      // 合并 codes
+      for (var elem of config.codes) {
+        this.codes.add(elem);
+      }
+    }
+
+    this.opts = config.opts || {};
+
+    var httpModule = this.endpoint.startsWith('https://')
+      ? require('https') : require('http');
+    this.keepAliveAgent = new httpModule.Agent({
+      keepAlive: true,
+      keepAliveMsecs: 3000
+    });
+  }
+
+  request(action, params = {}, opts = {}) {
+    // 1. compose params and opts
+    opts = Object.assign({
+      headers: {
+        'x-sdk-client': helper.DEFAULT_CLIENT,
+        'user-agent': helper.DEFAULT_UA
+      }
+    }, this.opts, opts);
+
+    // format action until formatAction is false
+    if (opts.formatAction !== false) {
+      action = firstLetterUpper(action);
+    }
+
+    // format params until formatParams is false
+    if (opts.formatParams !== false) {
+      params = formatParams(params);
+    }
+    var defaults = this._buildParams();
+    params = Object.assign({Action: action}, defaults, params);
+
+    // 2. caculate signature
+    var method = (opts.method || 'GET').toUpperCase();
+    var normalized = normalize(params);
+    var canonicalized = canonicalize(normalized);
+    // 2.1 get string to sign
+    var stringToSign = `${method}&${encode('/')}&${encode(canonicalized)}`;
+    // 2.2 get signature
+    const key = this.accessKeySecret + '&';
+    var signature = kitx.sha1(stringToSign, key, 'base64');
+    // add signature
+    normalized.push(['Signature', encode(signature)]);
+    // 3. generate final url
+    const url = opts.method === 'POST' ? `${this.endpoint}/` : `${this.endpoint}/?${canonicalize(normalized)}`;
+    // 4. send request
+    var entry = {
+      url: url,
+      request: null,
+      response: null
+    };
+
+    if (opts && !opts.agent) {
+      opts.agent = this.keepAliveAgent;
+    }
+
+    if (opts.method === 'POST') {
+      opts.headers = opts.headers || {};
+      opts.headers['content-type'] = 'application/x-www-form-urlencoded';
+      opts.data = canonicalize(normalized);
+    }
+
+    return httpx.request(url, opts).then((response) => {
+      entry.request = {
+        headers: response.req._headers
+      };
+      entry.response = {
+        statusCode: response.statusCode,
+        headers: response.headers
+      };
+
+      return httpx.read(response);
+    }).then((buffer) => {
+      var json = JSON.parse(buffer);
+      if (json.Code && !this.codes.has(json.Code)) {
+        var err = new Error(`${json.Message}, URL: ${url}`);
+        err.name = json.Code + 'Error';
+        err.data = json;
+        err.code = json.Code;
+        err.url = url;
+        err.entry = entry;
+        return Promise.reject(err);
+      }
+
+      if (this.verbose) {
+        return [json, entry];
+      }
+
+      return json;
+    });
+  }
+
+  _buildParams() {
+    var defaultParams = {
+      Format: 'JSON',
+      SignatureMethod: 'HMAC-SHA1',
+      SignatureNonce: kitx.makeNonce(),
+      SignatureVersion: '1.0',
+      Timestamp: timestamp(),
+      AccessKeyId: this.accessKeyId,
+      Version: this.apiVersion,
+    };
+    if (this.securityToken) {
+      defaultParams.SecurityToken = this.securityToken;
+    }
+    return defaultParams;
+  }
+}
+
+module.exports = RPCClient;

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/node_modules/debug

+../../../_debug@3.2.6@debug
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/node_modules/httpx

+../../../_httpx@2.2.2@httpx
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/node_modules/json-bigint

+../../../_json-bigint@0.2.3@json-bigint
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/node_modules/kitx

+../../../_kitx@1.3.0@kitx
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/node_modules/xml2js

+../../../_xml2js@0.4.22@xml2js
\ No newline at end of file

bigdata/node_modules/_@alicloud_pop-core@1.7.7@@alicloud/pop-core/package.json

+{
+  "name": "@alicloud/pop-core",
+  "version": "1.7.7",
+  "description": "AliCloud POP SDK core",
+  "main": "index.js",
+  "types": "lib/rpc.d.ts",
+  "scripts": {
+    "lint": "eslint --fix lib test",
+    "test": "mocha -R spec test/*.test.js",
+    "test-cov": "nyc -r=html -r=text -r=lcov mocha -t 3000 -R spec test/*.test.js",
+    "test-integration": "mocha -R spec test/*.integration.js",
+    "ci": "npm run lint && npm run test-cov && codecov"
+  },
+  "keywords": [
+    "Aliyun",
+    "AliCloud",
+    "OpenAPI",
+    "POP",
+    "SDK",
+    "Core"
+  ],
+  "author": "Jackson Tian",
+  "license": "MIT",
+  "dependencies": {
+    "debug": "^3.1.0",
+    "httpx": "^2.1.2",
+    "json-bigint": "^0.2.3",
+    "kitx": "^1.2.1",
+    "xml2js": "^0.4.17"
+  },
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "devDependencies": {
+    "codecov": "^3.0.4",
+    "eslint": "^3.13.0",
+    "expect.js": "^0.3.1",
+    "mocha": "^4",
+    "muk": "^0.5.3",
+    "nyc": "^12.0.2",
+    "rewire": "^4.0.1"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aliyun/openapi-core-nodejs-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aliyun/openapi-core-nodejs-sdk/issues"
+  },
+  "homepage": "https://github.com/aliyun/openapi-core-nodejs-sdk#readme",
+  "__npminstall_done": "Tue Nov 19 2019 17:18:27 GMT+0800 (CST)",
+  "_from": "@alicloud/pop-core@1.7.7",
+  "_resolved": "https://registry.npm.taobao.org/@alicloud/pop-core/download/@alicloud/pop-core-1.7.7.tgz"
+}
\ No newline at end of file

bigdata/node_modules/_@types_color-name@1.1.1@@types/color-name/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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

bigdata/node_modules/_@types_color-name@1.1.1@@types/color-name/README.md

+# Installation
+> `npm install --save @types/color-name`
+
+# Summary
+This package contains type definitions for color-name ( https://github.com/colorjs/color-name ).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/color-name
+
+Additional Details
+ * Last updated: Wed, 13 Feb 2019 16:16:48 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by Junyoung Clare Jang <https://github.com/Ailrun>.

bigdata/node_modules/_@types_color-name@1.1.1@@types/color-name/index.d.ts

+// Type definitions for color-name 1.1
+// Project: https://github.com/colorjs/color-name
+// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Tuple of Red, Green, and Blue
+ * @example
+ * // Red = 55, Green = 70, Blue = 0
+ * const rgb: RGB = [55, 70, 0];
+ */
+export type RGB = [number, number, number];
+
+export const aliceblue: RGB;
+export const antiquewhite: RGB;
+export const aqua: RGB;
+export const aquamarine: RGB;
+export const azure: RGB;
+export const beige: RGB;
+export const bisque: RGB;
+export const black: RGB;
+export const blanchedalmond: RGB;
+export const blue: RGB;
+export const blueviolet: RGB;
+export const brown: RGB;
+export const burlywood: RGB;
+export const cadetblue: RGB;
+export const chartreuse: RGB;
+export const chocolate: RGB;
+export const coral: RGB;
+export const cornflowerblue: RGB;
+export const cornsilk: RGB;
+export const crimson: RGB;
+export const cyan: RGB;
+export const darkblue: RGB;
+export const darkcyan: RGB;
+export const darkgoldenrod: RGB;
+export const darkgray: RGB;
+export const darkgreen: RGB;
+export const darkgrey: RGB;
+export const darkkhaki: RGB;
+export const darkmagenta: RGB;
+export const darkolivegreen: RGB;
+export const darkorange: RGB;
+export const darkorchid: RGB;
+export const darkred: RGB;
+export const darksalmon: RGB;
+export const darkseagreen: RGB;
+export const darkslateblue: RGB;
+export const darkslategray: RGB;
+export const darkslategrey: RGB;
+export const darkturquoise: RGB;
+export const darkviolet: RGB;
+export const deeppink: RGB;
+export const deepskyblue: RGB;
+export const dimgray: RGB;
+export const dimgrey: RGB;
+export const dodgerblue: RGB;
+export const firebrick: RGB;
+export const floralwhite: RGB;
+export const forestgreen: RGB;
+export const fuchsia: RGB;
+export const gainsboro: RGB;
+export const ghostwhite: RGB;
+export const gold: RGB;
+export const goldenrod: RGB;
+export const gray: RGB;
+export const green: RGB;
+export const greenyellow: RGB;
+export const grey: RGB;
+export const honeydew: RGB;
+export const hotpink: RGB;
+export const indianred: RGB;
+export const indigo: RGB;
+export const ivory: RGB;
+export const khaki: RGB;
+export const lavender: RGB;
+export const lavenderblush: RGB;
+export const lawngreen: RGB;
+export const lemonchiffon: RGB;
+export const lightblue: RGB;
+export const lightcoral: RGB;
+export const lightcyan: RGB;
+export const lightgoldenrodyellow: RGB;
+export const lightgray: RGB;
+export const lightgreen: RGB;
+export const lightgrey: RGB;
+export const lightpink: RGB;
+export const lightsalmon: RGB;
+export const lightseagreen: RGB;
+export const lightskyblue: RGB;
+export const lightslategray: RGB;
+export const lightslategrey: RGB;
+export const lightsteelblue: RGB;
+export const lightyellow: RGB;
+export const lime: RGB;
+export const limegreen: RGB;
+export const linen: RGB;
+export const magenta: RGB;
+export const maroon: RGB;
+export const mediumaquamarine: RGB;
+export const mediumblue: RGB;
+export const mediumorchid: RGB;
+export const mediumpurple: RGB;
+export const mediumseagreen: RGB;
+export const mediumslateblue: RGB;
+export const mediumspringgreen: RGB;
+export const mediumturquoise: RGB;
+export const mediumvioletred: RGB;
+export const midnightblue: RGB;
+export const mintcream: RGB;
+export const mistyrose: RGB;
+export const moccasin: RGB;
+export const navajowhite: RGB;
+export const navy: RGB;
+export const oldlace: RGB;
+export const olive: RGB;
+export const olivedrab: RGB;
+export const orange: RGB;
+export const orangered: RGB;
+export const orchid: RGB;
+export const palegoldenrod: RGB;
+export const palegreen: RGB;
+export const paleturquoise: RGB;
+export const palevioletred: RGB;
+export const papayawhip: RGB;
+export const peachpuff: RGB;
+export const peru: RGB;
+export const pink: RGB;
+export const plum: RGB;
+export const powderblue: RGB;
+export const purple: RGB;
+export const rebeccapurple: RGB;
+export const red: RGB;
+export const rosybrown: RGB;
+export const royalblue: RGB;
+export const saddlebrown: RGB;
+export const salmon: RGB;
+export const sandybrown: RGB;
+export const seagreen: RGB;
+export const seashell: RGB;
+export const sienna: RGB;
+export const silver: RGB;
+export const skyblue: RGB;
+export const slateblue: RGB;
+export const slategray: RGB;
+export const slategrey: RGB;
+export const snow: RGB;
+export const springgreen: RGB;
+export const steelblue: RGB;
+export const tan: RGB;
+export const teal: RGB;
+export const thistle: RGB;
+export const tomato: RGB;
+export const turquoise: RGB;
+export const violet: RGB;
+export const wheat: RGB;
+export const white: RGB;
+export const whitesmoke: RGB;
+export const yellow: RGB;
+export const yellowgreen: RGB;

bigdata/node_modules/_@types_color-name@1.1.1@@types/color-name/package.json

+{
+  "name": "@types/color-name",
+  "version": "1.1.1",
+  "description": "TypeScript definitions for color-name",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Junyoung Clare Jang",
+      "url": "https://github.com/Ailrun",
+      "githubUsername": "Ailrun"
+    }
+  ],
+  "main": "",
+  "types": "index",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "typesPublisherContentHash": "e22c6881e2dcf766e32142cbb82d9acf9c08258bdf0da8e76c8a448d1be44ac7",
+  "typeScriptVersion": "2.0",
+  "__npminstall_done": "Tue Nov 19 2019 17:18:36 GMT+0800 (CST)",
+  "_from": "@types/color-name@1.1.1",
+  "_resolved": "https://registry.npm.taobao.org/@types/color-name/download/@types/color-name-1.1.1.tgz?cache=0&sync_timestamp=1573558068323&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2F%40types%2Fcolor-name%2Fdownload%2F%40types%2Fcolor-name-1.1.1.tgz"
+}
\ No newline at end of file

bigdata/node_modules/_@types_geojson@1.0.6@@types/geojson/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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

bigdata/node_modules/_@types_geojson@1.0.6@@types/geojson/README.md

+# Installation
+> `npm install --save @types/geojson`
+
+# Summary
+This package contains type definitions for GeoJSON Format Specification Revision (http://geojson.org/).
+
+# Details
+Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/geojson
+
+Additional Details
+ * Last updated: Wed, 01 Nov 2017 15:55:40 GMT
+ * Dependencies: none
+ * Global values: GeoJSON
+
+# Credits
+These definitions were written by Jacob Bruun <https://github.com/cobster>, Arne Schubert <https://github.com/atd-schubert>.

bigdata/node_modules/_@types_geojson@1.0.6@@types/geojson/index.d.ts

+// Type definitions for GeoJSON Format Specification Revision 1.0
+// Project: http://geojson.org/
+// Definitions by: Jacob Bruun <https://github.com/cobster>
+//                 Arne Schubert <https://github.com/atd-schubert>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+export as namespace GeoJSON;
+
+/***
+ * http://geojson.org/geojson-spec.html#geojson-objects
+ */
+export interface GeoJsonObject {
+    type: string;
+    bbox?: number[];
+    crs?: CoordinateReferenceSystem;
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#positions
+ */
+export type Position = number[];
+
+/***
+ * http://geojson.org/geojson-spec.html#geometry-objects
+ */
+export interface DirectGeometryObject extends GeoJsonObject {
+    coordinates: Position[][][] | Position[][] | Position[] | Position;
+}
+/**
+ * GeometryObject supports geometry collection as well
+ */
+export type GeometryObject = DirectGeometryObject | GeometryCollection;
+
+/***
+ * http://geojson.org/geojson-spec.html#point
+ */
+export interface Point extends DirectGeometryObject {
+    type: "Point";
+    coordinates: Position;
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#multipoint
+ */
+export interface MultiPoint extends DirectGeometryObject {
+    type: "MultiPoint";
+    coordinates: Position[];
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#linestring
+ */
+export interface LineString extends DirectGeometryObject {
+    type: "LineString";
+    coordinates: Position[];
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#multilinestring
+ */
+export interface MultiLineString extends DirectGeometryObject {
+    type: "MultiLineString";
+    coordinates: Position[][];
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#polygon
+ */
+export interface Polygon extends DirectGeometryObject {
+    type: "Polygon";
+    coordinates: Position[][];
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#multipolygon
+ */
+export interface MultiPolygon extends DirectGeometryObject {
+    type: "MultiPolygon";
+    coordinates: Position[][][];
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#geometry-collection
+ */
+export interface GeometryCollection extends GeoJsonObject {
+    type: "GeometryCollection";
+    geometries: GeometryObject[];
+}
+
+/***
+ * https://tools.ietf.org/html/rfc7946#section-3.2
+ */
+export interface Feature<G extends GeometryObject, P = any> extends GeoJsonObject {
+    type: "Feature";
+    geometry: G;
+    properties: P;
+    id?: string | number;
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#feature-collection-objects
+ */
+export interface FeatureCollection<G extends GeometryObject, P = any> extends GeoJsonObject {
+    type: "FeatureCollection";
+    features: Array<Feature<G, P>>;
+}
+
+/***
+ * http://geojson.org/geojson-spec.html#coordinate-reference-system-objects
+ */
+export interface CoordinateReferenceSystem {
+    type: string;
+    properties: any;
+}
+
+export interface NamedCoordinateReferenceSystem extends CoordinateReferenceSystem {
+    properties: { name: string };
+}
+
+export interface LinkedCoordinateReferenceSystem extends CoordinateReferenceSystem {
+    properties: { href: string; type: string };
+}

bigdata/node_modules/_@types_geojson@1.0.6@@types/geojson/package.json

+{
+  "name": "@types/geojson",
+  "version": "1.0.6",
+  "description": "TypeScript definitions for GeoJSON Format Specification Revision",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Jacob Bruun",
+      "url": "https://github.com/cobster",
+      "githubUsername": "cobster"
+    },
+    {
+      "name": "Arne Schubert",
+      "url": "https://github.com/atd-schubert",
+      "githubUsername": "atd-schubert"
+    }
+  ],
+  "main": "",
+  "repository": {
+    "type": "git",
+    "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "typesPublisherContentHash": "2a374692a48615d90fde45b274e247a1ec98647d93fe7c7ee355386108689bcd",
+  "typeScriptVersion": "2.3",
+  "__npminstall_done": "Tue Nov 19 2019 17:18:36 GMT+0800 (CST)",
+  "_from": "@types/geojson@1.0.6",
+  "_resolved": "https://registry.npm.taobao.org/@types/geojson/download/@types/geojson-1.0.6.tgz"
+}
\ No newline at end of file

bigdata/node_modules/_@types_node@12.12.9@@types/node/LICENSE

+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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

bigdata/node_modules/_@types_node@12.12.9@@types/node/README.md

+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (http://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
+
+### Additional Details
+ * Last updated: Mon, 18 Nov 2019 20:48:11 GMT
+ * Dependencies: none
+ * Global values: `Buffer`, `NodeJS`, `Symbol`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+
+# Credits
+These definitions were written by Microsoft TypeScript (https://github.com/Microsoft), DefinitelyTyped (https://github.com/DefinitelyTyped), Alberto Schiabel (https://github.com/jkomyno), Alexander T. (https://github.com/a-tarasyuk), Alvis HT Tang (https://github.com/alvis), Andrew Makarov (https://github.com/r3nya), Benjamin Toueg (https://github.com/btoueg), Bruno Scheufler (https://github.com/brunoscheufler), Chigozirim C. (https://github.com/smac89), Christian Vaagland Tellnes (https://github.com/tellnes), David Junger (https://github.com/touffy), Deividas Bakanas (https://github.com/DeividasBakanas), Eugene Y. Q. Shen (https://github.com/eyqs), Flarna (https://github.com/Flarna), Hannes Magnusson (https://github.com/Hannes-Magnusson-CK), Hoàng Văn Khải (https://github.com/KSXGitHub), Huw (https://github.com/hoo29), Kelvin Jin (https://github.com/kjin), Klaus Meinhardt (https://github.com/ajafff), Lishude (https://github.com/islishude), Mariusz Wiktorczyk (https://github.com/mwiktorczyk), Mohsen Azimi (https://github.com/mohsen1), Nicolas Even (https://github.com/n-e), Nicolas Voigt (https://github.com/octo-sniffle), Nikita Galkin (https://github.com/galkin), Parambir Singh (https://github.com/parambirs), Sebastian Silbermann (https://github.com/eps1lon), Simon Schick (https://github.com/SimonSchick), Thomas den Hollander (https://github.com/ThomasdenH), Wilco Bakker (https://github.com/WilcoBakker), wwwy3y3 (https://github.com/wwwy3y3), Zane Hannan AU (https://github.com/ZaneHannanAU), Samuel Ainsworth (https://github.com/samuela), Kyle Uehlein (https://github.com/kuehlein), Jordi Oliveras Rovira (https://github.com/j-oliveras), Thanik Bhongbhibhat (https://github.com/bhongy), Marcin Kopacz (https://github.com/chyzwar), Trivikram Kamat (https://github.com/trivikr), and Minh Son Nguyen (https://github.com/nguymin4).

bigdata/node_modules/_@types_node@12.12.9@@types/node/assert.d.ts

+declare module "assert" {
+    function internal(value: any, message?: string | Error): void;
+    namespace internal {
+        class AssertionError implements Error {
+            name: string;
+            message: string;
+            actual: any;
+            expected: any;
+            operator: string;
+            generatedMessage: boolean;
+            code: 'ERR_ASSERTION';
+
+            constructor(options?: {
+                message?: string; actual?: any; expected?: any;
+                operator?: string; stackStartFn?: Function
+            });
+        }
+
+        function fail(message?: string | Error): never;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(actual: any, expected: any, message?: string | Error, operator?: string, stackStartFn?: Function): never;
+        function ok(value: any, message?: string | Error): void;
+        function equal(actual: any, expected: any, message?: string | Error): void;
+        function notEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepEqual(actual: any, expected: any, message?: string | Error): void;
+        function notDeepEqual(actual: any, expected: any, message?: string | Error): void;
+        function strictEqual(actual: any, expected: any, message?: string | Error): void;
+        function notStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+
+        function throws(block: () => any, message?: string | Error): void;
+        function throws(block: () => any, error: RegExp | Function | Object | Error, message?: string | Error): void;
+        function doesNotThrow(block: () => any, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void;
+
+        function ifError(value: any): void;
+
+        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(block: (() => Promise<any>) | Promise<any>, error: RegExp | Function | Object | Error, message?: string | Error): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, error: RegExp | Function, message?: string | Error): Promise<void>;
+
+        const strict: typeof internal;
+    }
+
+    export = internal;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/async_hooks.d.ts

+/**
+ * Async Hooks module: https://nodejs.org/api/async_hooks.html
+ */
+declare module "async_hooks" {
+    /**
+     * Returns the asyncId of the current execution context.
+     */
+    function executionAsyncId(): number;
+
+    /**
+     * Returns the ID of the resource responsible for calling the callback that is currently being executed.
+     */
+    function triggerAsyncId(): number;
+
+    interface HookCallbacks {
+        /**
+         * Called when a class is constructed that has the possibility to emit an asynchronous event.
+         * @param asyncId a unique ID for the async resource
+         * @param type the type of the async resource
+         * @param triggerAsyncId the unique ID of the async resource in whose execution context this async resource was created
+         * @param resource reference to the resource representing the async operation, needs to be released during destroy
+         */
+        init?(asyncId: number, type: string, triggerAsyncId: number, resource: Object): void;
+
+        /**
+         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
+         * The before callback is called just before said callback is executed.
+         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
+         */
+        before?(asyncId: number): void;
+
+        /**
+         * Called immediately after the callback specified in before is completed.
+         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
+         */
+        after?(asyncId: number): void;
+
+        /**
+         * Called when a promise has resolve() called. This may not be in the same execution id
+         * as the promise itself.
+         * @param asyncId the unique id for the promise that was resolve()d.
+         */
+        promiseResolve?(asyncId: number): void;
+
+        /**
+         * Called after the resource corresponding to asyncId is destroyed
+         * @param asyncId a unique ID for the async resource
+         */
+        destroy?(asyncId: number): void;
+    }
+
+    interface AsyncHook {
+        /**
+         * Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
+         */
+        enable(): this;
+
+        /**
+         * Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
+         */
+        disable(): this;
+    }
+
+    /**
+     * Registers functions to be called for different lifetime events of each async operation.
+     * @param options the callbacks to register
+     * @return an AsyncHooks instance used for disabling and enabling hooks
+     */
+    function createHook(options: HookCallbacks): AsyncHook;
+
+    interface AsyncResourceOptions {
+      /**
+       * The ID of the execution context that created this async event.
+       * Default: `executionAsyncId()`
+       */
+      triggerAsyncId?: number;
+
+      /**
+       * Disables automatic `emitDestroy` when the object is garbage collected.
+       * This usually does not need to be set (even if `emitDestroy` is called
+       * manually), unless the resource's `asyncId` is retrieved and the
+       * sensitive API's `emitDestroy` is called with it.
+       * Default: `false`
+       */
+      requireManualDestroy?: boolean;
+    }
+
+    /**
+     * The class AsyncResource was designed to be extended by the embedder's async resources.
+     * Using this users can easily trigger the lifetime events of their own resources.
+     */
+    class AsyncResource {
+        /**
+         * AsyncResource() is meant to be extended. Instantiating a
+         * new AsyncResource() also triggers init. If triggerAsyncId is omitted then
+         * async_hook.executionAsyncId() is used.
+         * @param type The type of async event.
+         * @param triggerAsyncId The ID of the execution context that created
+         *   this async event (default: `executionAsyncId()`), or an
+         *   AsyncResourceOptions object (since 9.3)
+         */
+        constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
+
+        /**
+         * Call the provided function with the provided arguments in the
+         * execution context of the async resource. This will establish the
+         * context, trigger the AsyncHooks before callbacks, call the function,
+         * trigger the AsyncHooks after callbacks, and then restore the original
+         * execution context.
+         * @param fn The function to call in the execution context of this
+         *   async resource.
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
+
+        /**
+         * Call AsyncHooks destroy callbacks.
+         */
+        emitDestroy(): void;
+
+        /**
+         * @return the unique ID assigned to this AsyncResource instance.
+         */
+        asyncId(): number;
+
+        /**
+         * @return the trigger ID for this AsyncResource instance.
+         */
+        triggerAsyncId(): number;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/base.d.ts

+// base definnitions for all NodeJS modules that are not specific to any version of TypeScript
+/// <reference path="globals.d.ts" />
+/// <reference path="assert.d.ts" />
+/// <reference path="async_hooks.d.ts" />
+/// <reference path="buffer.d.ts" />
+/// <reference path="child_process.d.ts" />
+/// <reference path="cluster.d.ts" />
+/// <reference path="console.d.ts" />
+/// <reference path="constants.d.ts" />
+/// <reference path="crypto.d.ts" />
+/// <reference path="dgram.d.ts" />
+/// <reference path="dns.d.ts" />
+/// <reference path="domain.d.ts" />
+/// <reference path="events.d.ts" />
+/// <reference path="fs.d.ts" />
+/// <reference path="http.d.ts" />
+/// <reference path="http2.d.ts" />
+/// <reference path="https.d.ts" />
+/// <reference path="inspector.d.ts" />
+/// <reference path="module.d.ts" />
+/// <reference path="net.d.ts" />
+/// <reference path="os.d.ts" />
+/// <reference path="path.d.ts" />
+/// <reference path="perf_hooks.d.ts" />
+/// <reference path="process.d.ts" />
+/// <reference path="punycode.d.ts" />
+/// <reference path="querystring.d.ts" />
+/// <reference path="readline.d.ts" />
+/// <reference path="repl.d.ts" />
+/// <reference path="stream.d.ts" />
+/// <reference path="string_decoder.d.ts" />
+/// <reference path="timers.d.ts" />
+/// <reference path="tls.d.ts" />
+/// <reference path="trace_events.d.ts" />
+/// <reference path="tty.d.ts" />
+/// <reference path="url.d.ts" />
+/// <reference path="util.d.ts" />
+/// <reference path="v8.d.ts" />
+/// <reference path="vm.d.ts" />
+/// <reference path="worker_threads.d.ts" />
+/// <reference path="zlib.d.ts" />

bigdata/node_modules/_@types_node@12.12.9@@types/node/buffer.d.ts

+declare module "buffer" {
+    export const INSPECT_MAX_BYTES: number;
+    export const kMaxLength: number;
+    export const kStringMaxLength: number;
+    export const constants: {
+        MAX_LENGTH: number;
+        MAX_STRING_LENGTH: number;
+    };
+    const BuffType: typeof Buffer;
+
+    export type TranscodeEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "latin1" | "binary";
+
+    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
+
+    export const SlowBuffer: {
+        /** @deprecated since v6.0.0, use Buffer.allocUnsafeSlow() */
+        new(size: number): Buffer;
+        prototype: Buffer;
+    };
+
+    export { BuffType as Buffer };
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/console.d.ts

+declare module "console" {
+    export = console;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/dgram.d.ts

+declare module "dgram" {
+    import { AddressInfo } from "net";
+    import * as dns from "dns";
+    import * as events from "events";
+
+    interface RemoteInfo {
+        address: string;
+        family: 'IPv4' | 'IPv6';
+        port: number;
+        size: number;
+    }
+
+    interface BindOptions {
+        port: number;
+        address?: string;
+        exclusive?: boolean;
+    }
+
+    type SocketType = "udp4" | "udp6";
+
+    interface SocketOptions {
+        type: SocketType;
+        reuseAddr?: boolean;
+        /**
+         * @default false
+         */
+        ipv6Only?: boolean;
+        recvBufferSize?: number;
+        sendBufferSize?: number;
+        lookup?: (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;
+    }
+
+    function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
+    function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
+
+    class Socket extends events.EventEmitter {
+        send(msg: string | Uint8Array | any[], port: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        send(msg: string | Uint8Array, offset: number, length: number, port: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
+        bind(port?: number, address?: string, callback?: () => void): void;
+        bind(port?: number, callback?: () => void): void;
+        bind(callback?: () => void): void;
+        bind(options: BindOptions, callback?: () => void): void;
+        close(callback?: () => void): void;
+        address(): AddressInfo | string;
+        setBroadcast(flag: boolean): void;
+        setTTL(ttl: number): void;
+        setMulticastTTL(ttl: number): void;
+        setMulticastInterface(multicastInterface: string): void;
+        setMulticastLoopback(flag: boolean): void;
+        addMembership(multicastAddress: string, multicastInterface?: string): void;
+        dropMembership(multicastAddress: string, multicastInterface?: string): void;
+        ref(): this;
+        unref(): this;
+        setRecvBufferSize(size: number): void;
+        setSendBufferSize(size: number): void;
+        getRecvBufferSize(): number;
+        getSendBufferSize(): number;
+
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. error
+         * 3. listening
+         * 4. message
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "listening", listener: () => void): this;
+        addListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "listening"): boolean;
+        emit(event: "message", msg: Buffer, rinfo: RemoteInfo): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "listening", listener: () => void): this;
+        on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "listening", listener: () => void): this;
+        once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "listening", listener: () => void): this;
+        prependListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "listening", listener: () => void): this;
+        prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/domain.d.ts

+declare module "domain" {
+    import * as events from "events";
+
+    class Domain extends events.EventEmitter implements NodeJS.Domain {
+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+        add(emitter: events.EventEmitter | NodeJS.Timer): void;
+        remove(emitter: events.EventEmitter | NodeJS.Timer): void;
+        bind<T extends Function>(cb: T): T;
+        intercept<T extends Function>(cb: T): T;
+        members: Array<events.EventEmitter | NodeJS.Timer>;
+        enter(): void;
+        exit(): void;
+    }
+
+    function create(): Domain;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/events.d.ts

+declare module "events" {
+    class internal extends NodeJS.EventEmitter { }
+
+    interface NodeEventTarget {
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+
+    interface DOMEventTarget {
+        addEventListener(event: string, listener: (...args: any[]) => void, opts?: { once: boolean }): any;
+    }
+
+    namespace internal {
+        function once(emitter: NodeEventTarget, event: string | symbol): Promise<any[]>;
+        function once(emitter: DOMEventTarget, event: string): Promise<any[]>;
+         class EventEmitter extends internal {
+            /** @deprecated since v4.0.0 */
+            static listenerCount(emitter: EventEmitter, event: string | symbol): number;
+            static defaultMaxListeners: number;
+
+            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            on(event: string | symbol, listener: (...args: any[]) => void): this;
+            once(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            off(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeAllListeners(event?: string | symbol): this;
+            setMaxListeners(n: number): this;
+            getMaxListeners(): number;
+            listeners(event: string | symbol): Function[];
+            rawListeners(event: string | symbol): Function[];
+            emit(event: string | symbol, ...args: any[]): boolean;
+            eventNames(): Array<string | symbol>;
+            listenerCount(type: string | symbol): number;
+        }
+    }
+
+    export = internal;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/https.d.ts

+declare module "https" {
+    import * as tls from "tls";
+    import * as events from "events";
+    import * as http from "http";
+    import { URL } from "url";
+
+    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
+
+    type RequestOptions = http.RequestOptions & tls.SecureContextOptions & {
+        rejectUnauthorized?: boolean; // Defaults to true
+        servername?: string; // SNI TLS Extension
+    };
+
+    interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
+        rejectUnauthorized?: boolean;
+        maxCachedSessions?: number;
+    }
+
+    class Agent extends http.Agent {
+        constructor(options?: AgentOptions);
+        options: AgentOptions;
+    }
+
+    class Server extends tls.Server {
+        constructor(requestListener?: http.RequestListener);
+        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+
+        setTimeout(callback: () => void): this;
+        setTimeout(msecs?: number, callback?: () => void): this;
+        /**
+         * Limits maximum incoming headers count. If set to 0, no limit will be applied.
+         * @default 2000
+         * {@link https://nodejs.org/api/http.html#http_server_maxheaderscount}
+         */
+        maxHeadersCount: number | null;
+        timeout: number;
+        /**
+         * Limit the amount of time the parser will wait to receive the complete HTTP headers.
+         * @default 40000
+         * {@link https://nodejs.org/api/http.html#http_server_headerstimeout}
+         */
+        headersTimeout: number;
+        keepAliveTimeout: number;
+    }
+
+    function createServer(requestListener?: http.RequestListener): Server;
+    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
+    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    let globalAgent: Agent;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/index.d.ts

+// Type definitions for non-npm package Node.js 12.12
+// Project: http://nodejs.org/
+// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
+//                 DefinitelyTyped <https://github.com/DefinitelyTyped>
+//                 Alberto Schiabel <https://github.com/jkomyno>
+//                 Alexander T. <https://github.com/a-tarasyuk>
+//                 Alvis HT Tang <https://github.com/alvis>
+//                 Andrew Makarov <https://github.com/r3nya>
+//                 Benjamin Toueg <https://github.com/btoueg>
+//                 Bruno Scheufler <https://github.com/brunoscheufler>
+//                 Chigozirim C. <https://github.com/smac89>
+//                 Christian Vaagland Tellnes <https://github.com/tellnes>
+//                 David Junger <https://github.com/touffy>
+//                 Deividas Bakanas <https://github.com/DeividasBakanas>
+//                 Eugene Y. Q. Shen <https://github.com/eyqs>
+//                 Flarna <https://github.com/Flarna>
+//                 Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>
+//                 Hoàng Văn Khải <https://github.com/KSXGitHub>
+//                 Huw <https://github.com/hoo29>
+//                 Kelvin Jin <https://github.com/kjin>
+//                 Klaus Meinhardt <https://github.com/ajafff>
+//                 Lishude <https://github.com/islishude>
+//                 Mariusz Wiktorczyk <https://github.com/mwiktorczyk>
+//                 Mohsen Azimi <https://github.com/mohsen1>
+//                 Nicolas Even <https://github.com/n-e>
+//                 Nicolas Voigt <https://github.com/octo-sniffle>
+//                 Nikita Galkin <https://github.com/galkin>
+//                 Parambir Singh <https://github.com/parambirs>
+//                 Sebastian Silbermann <https://github.com/eps1lon>
+//                 Simon Schick <https://github.com/SimonSchick>
+//                 Thomas den Hollander <https://github.com/ThomasdenH>
+//                 Wilco Bakker <https://github.com/WilcoBakker>
+//                 wwwy3y3 <https://github.com/wwwy3y3>
+//                 Zane Hannan AU <https://github.com/ZaneHannanAU>
+//                 Samuel Ainsworth <https://github.com/samuela>
+//                 Kyle Uehlein <https://github.com/kuehlein>
+//                 Jordi Oliveras Rovira <https://github.com/j-oliveras>
+//                 Thanik Bhongbhibhat <https://github.com/bhongy>
+//                 Marcin Kopacz <https://github.com/chyzwar>
+//                 Trivikram Kamat <https://github.com/trivikr>
+//                 Minh Son Nguyen <https://github.com/nguymin4>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// NOTE: These definitions support NodeJS and TypeScript 3.2.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.2/index.d.ts  - Definitions specific to TypeScript 3.2
+
+// NOTE: Augmentations for TypeScript 3.2 and later should use individual files for overrides
+//       within the respective ~/ts3.2 (or later) folder. However, this is disallowed for versions
+//       prior to TypeScript 3.2, so the older definitions will be found here.
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+/// <reference path="base.d.ts" />
+
+// TypeScript 2.1-specific augmentations:
+
+// Forward-declarations for needed types from es2015 and later (in case users are using `--lib es5`)
+// Empty interfaces are used here which merge fine with the real declarations in the lib XXX files
+// just to ensure the names are known and node typings can be sued without importing these libs.
+// if someone really needs these types the libs need to be added via --lib or in tsconfig.json
+interface MapConstructor { }
+interface WeakMapConstructor { }
+interface SetConstructor { }
+interface WeakSetConstructor { }
+interface Set<T> {}
+interface Map<K, V> {}
+interface ReadonlySet<T> {}
+interface Iterable<T> { }
+interface IteratorResult<T> { }
+interface AsyncIterable<T> { }
+interface Iterator<T> {
+    next(value?: any): IteratorResult<T>;
+}
+interface IterableIterator<T> { }
+interface AsyncIterableIterator<T> {}
+interface SymbolConstructor {
+    readonly iterator: symbol;
+    readonly asyncIterator: symbol;
+}
+declare var Symbol: SymbolConstructor;
+// even this is just a forward declaration some properties are added otherwise
+// it would be allowed to pass anything to e.g. Buffer.from()
+interface SharedArrayBuffer {
+    readonly byteLength: number;
+    slice(begin?: number, end?: number): SharedArrayBuffer;
+}
+
+declare module "util" {
+    namespace inspect {
+        const custom: symbol;
+    }
+    namespace promisify {
+        const custom: symbol;
+    }
+    namespace types {
+        function isBigInt64Array(value: any): boolean;
+        function isBigUint64Array(value: any): boolean;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/module.d.ts

+declare module "module" {
+    export = NodeJS.Module;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/os.d.ts

+declare module "os" {
+    interface CpuInfo {
+        model: string;
+        speed: number;
+        times: {
+            user: number;
+            nice: number;
+            sys: number;
+            idle: number;
+            irq: number;
+        };
+    }
+
+    interface NetworkInterfaceBase {
+        address: string;
+        netmask: string;
+        mac: string;
+        internal: boolean;
+        cidr: string | null;
+    }
+
+    interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
+        family: "IPv4";
+    }
+
+    interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
+        family: "IPv6";
+        scopeid: number;
+    }
+
+    interface UserInfo<T> {
+        username: T;
+        uid: number;
+        gid: number;
+        shell: T;
+        homedir: T;
+    }
+
+    type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
+
+    function hostname(): string;
+    function loadavg(): number[];
+    function uptime(): number;
+    function freemem(): number;
+    function totalmem(): number;
+    function cpus(): CpuInfo[];
+    function type(): string;
+    function release(): string;
+    function networkInterfaces(): { [index: string]: NetworkInterfaceInfo[] };
+    function homedir(): string;
+    function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
+    function userInfo(options?: { encoding: string }): UserInfo<string>;
+    const constants: {
+        UV_UDP_REUSEADDR: number;
+        // signals: { [key in NodeJS.Signals]: number; }; @todo: change after migration to typescript 2.1
+        signals: {
+            SIGHUP: number;
+            SIGINT: number;
+            SIGQUIT: number;
+            SIGILL: number;
+            SIGTRAP: number;
+            SIGABRT: number;
+            SIGIOT: number;
+            SIGBUS: number;
+            SIGFPE: number;
+            SIGKILL: number;
+            SIGUSR1: number;
+            SIGSEGV: number;
+            SIGUSR2: number;
+            SIGPIPE: number;
+            SIGALRM: number;
+            SIGTERM: number;
+            SIGCHLD: number;
+            SIGSTKFLT: number;
+            SIGCONT: number;
+            SIGSTOP: number;
+            SIGTSTP: number;
+            SIGBREAK: number;
+            SIGTTIN: number;
+            SIGTTOU: number;
+            SIGURG: number;
+            SIGXCPU: number;
+            SIGXFSZ: number;
+            SIGVTALRM: number;
+            SIGPROF: number;
+            SIGWINCH: number;
+            SIGIO: number;
+            SIGPOLL: number;
+            SIGLOST: number;
+            SIGPWR: number;
+            SIGINFO: number;
+            SIGSYS: number;
+            SIGUNUSED: number;
+        };
+        errno: {
+            E2BIG: number;
+            EACCES: number;
+            EADDRINUSE: number;
+            EADDRNOTAVAIL: number;
+            EAFNOSUPPORT: number;
+            EAGAIN: number;
+            EALREADY: number;
+            EBADF: number;
+            EBADMSG: number;
+            EBUSY: number;
+            ECANCELED: number;
+            ECHILD: number;
+            ECONNABORTED: number;
+            ECONNREFUSED: number;
+            ECONNRESET: number;
+            EDEADLK: number;
+            EDESTADDRREQ: number;
+            EDOM: number;
+            EDQUOT: number;
+            EEXIST: number;
+            EFAULT: number;
+            EFBIG: number;
+            EHOSTUNREACH: number;
+            EIDRM: number;
+            EILSEQ: number;
+            EINPROGRESS: number;
+            EINTR: number;
+            EINVAL: number;
+            EIO: number;
+            EISCONN: number;
+            EISDIR: number;
+            ELOOP: number;
+            EMFILE: number;
+            EMLINK: number;
+            EMSGSIZE: number;
+            EMULTIHOP: number;
+            ENAMETOOLONG: number;
+            ENETDOWN: number;
+            ENETRESET: number;
+            ENETUNREACH: number;
+            ENFILE: number;
+            ENOBUFS: number;
+            ENODATA: number;
+            ENODEV: number;
+            ENOENT: number;
+            ENOEXEC: number;
+            ENOLCK: number;
+            ENOLINK: number;
+            ENOMEM: number;
+            ENOMSG: number;
+            ENOPROTOOPT: number;
+            ENOSPC: number;
+            ENOSR: number;
+            ENOSTR: number;
+            ENOSYS: number;
+            ENOTCONN: number;
+            ENOTDIR: number;
+            ENOTEMPTY: number;
+            ENOTSOCK: number;
+            ENOTSUP: number;
+            ENOTTY: number;
+            ENXIO: number;
+            EOPNOTSUPP: number;
+            EOVERFLOW: number;
+            EPERM: number;
+            EPIPE: number;
+            EPROTO: number;
+            EPROTONOSUPPORT: number;
+            EPROTOTYPE: number;
+            ERANGE: number;
+            EROFS: number;
+            ESPIPE: number;
+            ESRCH: number;
+            ESTALE: number;
+            ETIME: number;
+            ETIMEDOUT: number;
+            ETXTBSY: number;
+            EWOULDBLOCK: number;
+            EXDEV: number;
+            WSAEINTR: number;
+            WSAEBADF: number;
+            WSAEACCES: number;
+            WSAEFAULT: number;
+            WSAEINVAL: number;
+            WSAEMFILE: number;
+            WSAEWOULDBLOCK: number;
+            WSAEINPROGRESS: number;
+            WSAEALREADY: number;
+            WSAENOTSOCK: number;
+            WSAEDESTADDRREQ: number;
+            WSAEMSGSIZE: number;
+            WSAEPROTOTYPE: number;
+            WSAENOPROTOOPT: number;
+            WSAEPROTONOSUPPORT: number;
+            WSAESOCKTNOSUPPORT: number;
+            WSAEOPNOTSUPP: number;
+            WSAEPFNOSUPPORT: number;
+            WSAEAFNOSUPPORT: number;
+            WSAEADDRINUSE: number;
+            WSAEADDRNOTAVAIL: number;
+            WSAENETDOWN: number;
+            WSAENETUNREACH: number;
+            WSAENETRESET: number;
+            WSAECONNABORTED: number;
+            WSAECONNRESET: number;
+            WSAENOBUFS: number;
+            WSAEISCONN: number;
+            WSAENOTCONN: number;
+            WSAESHUTDOWN: number;
+            WSAETOOMANYREFS: number;
+            WSAETIMEDOUT: number;
+            WSAECONNREFUSED: number;
+            WSAELOOP: number;
+            WSAENAMETOOLONG: number;
+            WSAEHOSTDOWN: number;
+            WSAEHOSTUNREACH: number;
+            WSAENOTEMPTY: number;
+            WSAEPROCLIM: number;
+            WSAEUSERS: number;
+            WSAEDQUOT: number;
+            WSAESTALE: number;
+            WSAEREMOTE: number;
+            WSASYSNOTREADY: number;
+            WSAVERNOTSUPPORTED: number;
+            WSANOTINITIALISED: number;
+            WSAEDISCON: number;
+            WSAENOMORE: number;
+            WSAECANCELLED: number;
+            WSAEINVALIDPROCTABLE: number;
+            WSAEINVALIDPROVIDER: number;
+            WSAEPROVIDERFAILEDINIT: number;
+            WSASYSCALLFAILURE: number;
+            WSASERVICE_NOT_FOUND: number;
+            WSATYPE_NOT_FOUND: number;
+            WSA_E_NO_MORE: number;
+            WSA_E_CANCELLED: number;
+            WSAEREFUSED: number;
+        };
+        priority: {
+            PRIORITY_LOW: number;
+            PRIORITY_BELOW_NORMAL: number;
+            PRIORITY_NORMAL: number;
+            PRIORITY_ABOVE_NORMAL: number;
+            PRIORITY_HIGH: number;
+            PRIORITY_HIGHEST: number;
+        }
+    };
+    function arch(): string;
+    function platform(): NodeJS.Platform;
+    function tmpdir(): string;
+    const EOL: string;
+    function endianness(): "BE" | "LE";
+    /**
+     * Gets the priority of a process.
+     * Defaults to current process.
+     */
+    function getPriority(pid?: number): number;
+    /**
+     * Sets the priority of the current process.
+     * @param priority Must be in range of -20 to 19
+     */
+    function setPriority(priority: number): void;
+    /**
+     * Sets the priority of the process specified process.
+     * @param priority Must be in range of -20 to 19
+     */
+    function setPriority(pid: number, priority: number): void;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/package.json

+{
+  "name": "@types/node",
+  "version": "12.12.9",
+  "description": "TypeScript definitions for Node.js",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Microsoft TypeScript",
+      "url": "https://github.com/Microsoft",
+      "githubUsername": "Microsoft"
+    },
+    {
+      "name": "DefinitelyTyped",
+      "url": "https://github.com/DefinitelyTyped",
+      "githubUsername": "DefinitelyTyped"
+    },
+    {
+      "name": "Alberto Schiabel",
+      "url": "https://github.com/jkomyno",
+      "githubUsername": "jkomyno"
+    },
+    {
+      "name": "Alexander T.",
+      "url": "https://github.com/a-tarasyuk",
+      "githubUsername": "a-tarasyuk"
+    },
+    {
+      "name": "Alvis HT Tang",
+      "url": "https://github.com/alvis",
+      "githubUsername": "alvis"
+    },
+    {
+      "name": "Andrew Makarov",
+      "url": "https://github.com/r3nya",
+      "githubUsername": "r3nya"
+    },
+    {
+      "name": "Benjamin Toueg",
+      "url": "https://github.com/btoueg",
+      "githubUsername": "btoueg"
+    },
+    {
+      "name": "Bruno Scheufler",
+      "url": "https://github.com/brunoscheufler",
+      "githubUsername": "brunoscheufler"
+    },
+    {
+      "name": "Chigozirim C.",
+      "url": "https://github.com/smac89",
+      "githubUsername": "smac89"
+    },
+    {
+      "name": "Christian Vaagland Tellnes",
+      "url": "https://github.com/tellnes",
+      "githubUsername": "tellnes"
+    },
+    {
+      "name": "David Junger",
+      "url": "https://github.com/touffy",
+      "githubUsername": "touffy"
+    },
+    {
+      "name": "Deividas Bakanas",
+      "url": "https://github.com/DeividasBakanas",
+      "githubUsername": "DeividasBakanas"
+    },
+    {
+      "name": "Eugene Y. Q. Shen",
+      "url": "https://github.com/eyqs",
+      "githubUsername": "eyqs"
+    },
+    {
+      "name": "Flarna",
+      "url": "https://github.com/Flarna",
+      "githubUsername": "Flarna"
+    },
+    {
+      "name": "Hannes Magnusson",
+      "url": "https://github.com/Hannes-Magnusson-CK",
+      "githubUsername": "Hannes-Magnusson-CK"
+    },
+    {
+      "name": "Hoàng Văn Khải",
+      "url": "https://github.com/KSXGitHub",
+      "githubUsername": "KSXGitHub"
+    },
+    {
+      "name": "Huw",
+      "url": "https://github.com/hoo29",
+      "githubUsername": "hoo29"
+    },
+    {
+      "name": "Kelvin Jin",
+      "url": "https://github.com/kjin",
+      "githubUsername": "kjin"
+    },
+    {
+      "name": "Klaus Meinhardt",
+      "url": "https://github.com/ajafff",
+      "githubUsername": "ajafff"
+    },
+    {
+      "name": "Lishude",
+      "url": "https://github.com/islishude",
+      "githubUsername": "islishude"
+    },
+    {
+      "name": "Mariusz Wiktorczyk",
+      "url": "https://github.com/mwiktorczyk",
+      "githubUsername": "mwiktorczyk"
+    },
+    {
+      "name": "Mohsen Azimi",
+      "url": "https://github.com/mohsen1",
+      "githubUsername": "mohsen1"
+    },
+    {
+      "name": "Nicolas Even",
+      "url": "https://github.com/n-e",
+      "githubUsername": "n-e"
+    },
+    {
+      "name": "Nicolas Voigt",
+      "url": "https://github.com/octo-sniffle",
+      "githubUsername": "octo-sniffle"
+    },
+    {
+      "name": "Nikita Galkin",
+      "url": "https://github.com/galkin",
+      "githubUsername": "galkin"
+    },
+    {
+      "name": "Parambir Singh",
+      "url": "https://github.com/parambirs",
+      "githubUsername": "parambirs"
+    },
+    {
+      "name": "Sebastian Silbermann",
+      "url": "https://github.com/eps1lon",
+      "githubUsername": "eps1lon"
+    },
+    {
+      "name": "Simon Schick",
+      "url": "https://github.com/SimonSchick",
+      "githubUsername": "SimonSchick"
+    },
+    {
+      "name": "Thomas den Hollander",
+      "url": "https://github.com/ThomasdenH",
+      "githubUsername": "ThomasdenH"
+    },
+    {
+      "name": "Wilco Bakker",
+      "url": "https://github.com/WilcoBakker",
+      "githubUsername": "WilcoBakker"
+    },
+    {
+      "name": "wwwy3y3",
+      "url": "https://github.com/wwwy3y3",
+      "githubUsername": "wwwy3y3"
+    },
+    {
+      "name": "Zane Hannan AU",
+      "url": "https://github.com/ZaneHannanAU",
+      "githubUsername": "ZaneHannanAU"
+    },
+    {
+      "name": "Samuel Ainsworth",
+      "url": "https://github.com/samuela",
+      "githubUsername": "samuela"
+    },
+    {
+      "name": "Kyle Uehlein",
+      "url": "https://github.com/kuehlein",
+      "githubUsername": "kuehlein"
+    },
+    {
+      "name": "Jordi Oliveras Rovira",
+      "url": "https://github.com/j-oliveras",
+      "githubUsername": "j-oliveras"
+    },
+    {
+      "name": "Thanik Bhongbhibhat",
+      "url": "https://github.com/bhongy",
+      "githubUsername": "bhongy"
+    },
+    {
+      "name": "Marcin Kopacz",
+      "url": "https://github.com/chyzwar",
+      "githubUsername": "chyzwar"
+    },
+    {
+      "name": "Trivikram Kamat",
+      "url": "https://github.com/trivikr",
+      "githubUsername": "trivikr"
+    },
+    {
+      "name": "Minh Son Nguyen",
+      "url": "https://github.com/nguymin4",
+      "githubUsername": "nguymin4"
+    }
+  ],
+  "main": "",
+  "types": "index.d.ts",
+  "typesVersions": {
+    ">=3.2.0-0": {
+      "*": [
+        "ts3.2/*"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/node"
+  },
+  "scripts": {},
+  "dependencies": {},
+  "typesPublisherContentHash": "9c94a4ee4d32b9ff9fae5de2eb33fa954fbb96c5c84e749d38ed8560fdaeb9a0",
+  "typeScriptVersion": "2.8",
+  "__npminstall_done": "Tue Nov 19 2019 17:18:28 GMT+0800 (CST)",
+  "_from": "@types/node@12.12.9",
+  "_resolved": "https://registry.npm.taobao.org/@types/node/download/@types/node-12.12.9.tgz?cache=0&other_urls=https%3A%2F%2Fregistry.npm.taobao.org%2F%40types%2Fnode%2Fdownload%2F%40types%2Fnode-12.12.9.tgz"
+}
\ No newline at end of file

bigdata/node_modules/_@types_node@12.12.9@@types/node/path.d.ts

+declare module "path" {
+    /**
+     * A parsed path object generated by path.parse() or consumed by path.format().
+     */
+    interface ParsedPath {
+        /**
+         * The root of the path such as '/' or 'c:\'
+         */
+        root: string;
+        /**
+         * The full directory path such as '/home/user/dir' or 'c:\path\dir'
+         */
+        dir: string;
+        /**
+         * The file name including extension (if any) such as 'index.html'
+         */
+        base: string;
+        /**
+         * The file extension (if any) such as '.html'
+         */
+        ext: string;
+        /**
+         * The file name without extension (if any) such as 'index'
+         */
+        name: string;
+    }
+    interface FormatInputPathObject {
+        /**
+         * The root of the path such as '/' or 'c:\'
+         */
+        root?: string;
+        /**
+         * The full directory path such as '/home/user/dir' or 'c:\path\dir'
+         */
+        dir?: string;
+        /**
+         * The file name including extension (if any) such as 'index.html'
+         */
+        base?: string;
+        /**
+         * The file extension (if any) such as '.html'
+         */
+        ext?: string;
+        /**
+         * The file name without extension (if any) such as 'index'
+         */
+        name?: string;
+    }
+
+    /**
+     * Normalize a string path, reducing '..' and '.' parts.
+     * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
+     *
+     * @param p string path to normalize.
+     */
+    function normalize(p: string): string;
+    /**
+     * Join all arguments together and normalize the resulting path.
+     * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
+     *
+     * @param paths paths to join.
+     */
+    function join(...paths: string[]): string;
+    /**
+     * The right-most parameter is considered {to}.  Other parameters are considered an array of {from}.
+     *
+     * Starting from leftmost {from} parameter, resolves {to} to an absolute path.
+     *
+     * If {to} isn't already absolute, {from} arguments are prepended in right to left order,
+     * until an absolute path is found. If after using all {from} paths still no absolute path is found,
+     * the current working directory is used as well. The resulting path is normalized,
+     * and trailing slashes are removed unless the path gets resolved to the root directory.
+     *
+     * @param pathSegments string paths to join.  Non-string arguments are ignored.
+     */
+    function resolve(...pathSegments: string[]): string;
+    /**
+     * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
+     *
+     * @param path path to test.
+     */
+    function isAbsolute(path: string): boolean;
+    /**
+     * Solve the relative path from {from} to {to}.
+     * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
+     */
+    function relative(from: string, to: string): string;
+    /**
+     * Return the directory name of a path. Similar to the Unix dirname command.
+     *
+     * @param p the path to evaluate.
+     */
+    function dirname(p: string): string;
+    /**
+     * Return the last portion of a path. Similar to the Unix basename command.
+     * Often used to extract the file name from a fully qualified path.
+     *
+     * @param p the path to evaluate.
+     * @param ext optionally, an extension to remove from the result.
+     */
+    function basename(p: string, ext?: string): string;
+    /**
+     * Return the extension of the path, from the last '.' to end of string in the last portion of the path.
+     * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
+     *
+     * @param p the path to evaluate.
+     */
+    function extname(p: string): string;
+    /**
+     * The platform-specific file separator. '\\' or '/'.
+     */
+    const sep: '\\' | '/';
+    /**
+     * The platform-specific file delimiter. ';' or ':'.
+     */
+    const delimiter: ';' | ':';
+    /**
+     * Returns an object from a path string - the opposite of format().
+     *
+     * @param pathString path to evaluate.
+     */
+    function parse(pathString: string): ParsedPath;
+    /**
+     * Returns a path string from an object - the opposite of parse().
+     *
+     * @param pathString path to evaluate.
+     */
+    function format(pathObject: FormatInputPathObject): string;
+
+    namespace posix {
+        function normalize(p: string): string;
+        function join(...paths: string[]): string;
+        function resolve(...pathSegments: string[]): string;
+        function isAbsolute(p: string): boolean;
+        function relative(from: string, to: string): string;
+        function dirname(p: string): string;
+        function basename(p: string, ext?: string): string;
+        function extname(p: string): string;
+        const sep: string;
+        const delimiter: string;
+        function parse(p: string): ParsedPath;
+        function format(pP: FormatInputPathObject): string;
+    }
+
+    namespace win32 {
+        function normalize(p: string): string;
+        function join(...paths: string[]): string;
+        function resolve(...pathSegments: string[]): string;
+        function isAbsolute(p: string): boolean;
+        function relative(from: string, to: string): string;
+        function dirname(p: string): string;
+        function basename(p: string, ext?: string): string;
+        function extname(p: string): string;
+        const sep: string;
+        const delimiter: string;
+        function parse(p: string): ParsedPath;
+        function format(pP: FormatInputPathObject): string;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/process.d.ts

+declare module "process" {
+    import * as tty from "tty";
+
+    global {
+        namespace NodeJS {
+            // this namespace merge is here because these are specifically used
+            // as the type for process.stdin, process.stdout, and process.stderr.
+            // they can't live in tty.d.ts because we need to disambiguate the imported name.
+            interface ReadStream extends tty.ReadStream {}
+            interface WriteStream extends tty.WriteStream {}
+        }
+    }
+
+    export = process;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/punycode.d.ts

+declare module "punycode" {
+    function decode(string: string): string;
+    function encode(string: string): string;
+    function toUnicode(domain: string): string;
+    function toASCII(domain: string): string;
+    const ucs2: ucs2;
+    interface ucs2 {
+        decode(string: string): number[];
+        encode(codePoints: number[]): string;
+    }
+    const version: string;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/querystring.d.ts

+declare module "querystring" {
+    interface StringifyOptions {
+        encodeURIComponent?: (str: string) => string;
+    }
+
+    interface ParseOptions {
+        maxKeys?: number;
+        decodeURIComponent?: (str: string) => string;
+    }
+
+    interface ParsedUrlQuery { [key: string]: string | string[]; }
+
+    interface ParsedUrlQueryInput {
+        [key: string]: NodeJS.PoorMansUnknown;
+    }
+
+    function stringify(obj?: ParsedUrlQueryInput, sep?: string, eq?: string, options?: StringifyOptions): string;
+    function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): ParsedUrlQuery;
+    /**
+     * The querystring.encode() function is an alias for querystring.stringify().
+     */
+    const encode: typeof stringify;
+    /**
+     * The querystring.decode() function is an alias for querystring.parse().
+     */
+    const decode: typeof parse;
+    function escape(str: string): string;
+    function unescape(str: string): string;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/readline.d.ts

+declare module "readline" {
+    import * as events from "events";
+    import * as stream from "stream";
+
+    interface Key {
+        sequence?: string;
+        name?: string;
+        ctrl?: boolean;
+        meta?: boolean;
+        shift?: boolean;
+    }
+
+    class Interface extends events.EventEmitter {
+        readonly terminal: boolean;
+
+        /**
+         * NOTE: According to the documentation:
+         *
+         * > Instances of the `readline.Interface` class are constructed using the
+         * > `readline.createInterface()` method.
+         *
+         * @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
+         */
+        protected constructor(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean);
+        /**
+         * NOTE: According to the documentation:
+         *
+         * > Instances of the `readline.Interface` class are constructed using the
+         * > `readline.createInterface()` method.
+         *
+         * @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
+         */
+        protected constructor(options: ReadLineOptions);
+
+        setPrompt(prompt: string): void;
+        prompt(preserveCursor?: boolean): void;
+        question(query: string, callback: (answer: string) => void): void;
+        pause(): this;
+        resume(): this;
+        close(): void;
+        write(data: string | Buffer, key?: Key): void;
+
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. line
+         * 3. pause
+         * 4. resume
+         * 5. SIGCONT
+         * 6. SIGINT
+         * 7. SIGTSTP
+         */
+
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "line", listener: (input: string) => void): this;
+        addListener(event: "pause", listener: () => void): this;
+        addListener(event: "resume", listener: () => void): this;
+        addListener(event: "SIGCONT", listener: () => void): this;
+        addListener(event: "SIGINT", listener: () => void): this;
+        addListener(event: "SIGTSTP", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "line", input: string): boolean;
+        emit(event: "pause"): boolean;
+        emit(event: "resume"): boolean;
+        emit(event: "SIGCONT"): boolean;
+        emit(event: "SIGINT"): boolean;
+        emit(event: "SIGTSTP"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "line", listener: (input: string) => void): this;
+        on(event: "pause", listener: () => void): this;
+        on(event: "resume", listener: () => void): this;
+        on(event: "SIGCONT", listener: () => void): this;
+        on(event: "SIGINT", listener: () => void): this;
+        on(event: "SIGTSTP", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "line", listener: (input: string) => void): this;
+        once(event: "pause", listener: () => void): this;
+        once(event: "resume", listener: () => void): this;
+        once(event: "SIGCONT", listener: () => void): this;
+        once(event: "SIGINT", listener: () => void): this;
+        once(event: "SIGTSTP", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "line", listener: (input: string) => void): this;
+        prependListener(event: "pause", listener: () => void): this;
+        prependListener(event: "resume", listener: () => void): this;
+        prependListener(event: "SIGCONT", listener: () => void): this;
+        prependListener(event: "SIGINT", listener: () => void): this;
+        prependListener(event: "SIGTSTP", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "line", listener: (input: string) => void): this;
+        prependOnceListener(event: "pause", listener: () => void): this;
+        prependOnceListener(event: "resume", listener: () => void): this;
+        prependOnceListener(event: "SIGCONT", listener: () => void): this;
+        prependOnceListener(event: "SIGINT", listener: () => void): this;
+        prependOnceListener(event: "SIGTSTP", listener: () => void): this;
+        [Symbol.asyncIterator](): AsyncIterableIterator<string>;
+    }
+
+    type ReadLine = Interface; // type forwarded for backwards compatiblity
+
+    type Completer = (line: string) => CompleterResult;
+    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => any;
+
+    type CompleterResult = [string[], string];
+
+    interface ReadLineOptions {
+        input: NodeJS.ReadableStream;
+        output?: NodeJS.WritableStream;
+        completer?: Completer | AsyncCompleter;
+        terminal?: boolean;
+        historySize?: number;
+        prompt?: string;
+        crlfDelay?: number;
+        removeHistoryDuplicates?: boolean;
+    }
+
+    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
+    function createInterface(options: ReadLineOptions): Interface;
+    function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
+
+    type Direction = -1 | 0 | 1;
+
+    /**
+     * Clears the current line of this WriteStream in a direction identified by `dir`.
+     */
+    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    /**
+     * Clears this `WriteStream` from the current cursor down.
+     */
+    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    /**
+     * Moves this WriteStream's cursor to the specified position.
+     */
+    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    /**
+     * Moves this WriteStream's cursor relative to its current position.
+     */
+    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/string_decoder.d.ts

+declare module "string_decoder" {
+    class StringDecoder {
+        constructor(encoding?: string);
+        write(buffer: Buffer): string;
+        end(buffer?: Buffer): string;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/timers.d.ts

+declare module "timers" {
+    function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timeout;
+    namespace setTimeout {
+        function __promisify__(ms: number): Promise<void>;
+        function __promisify__<T>(ms: number, value: T): Promise<T>;
+    }
+    function clearTimeout(timeoutId: NodeJS.Timeout): void;
+    function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timeout;
+    function clearInterval(intervalId: NodeJS.Timeout): void;
+    function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
+    namespace setImmediate {
+        function __promisify__(): Promise<void>;
+        function __promisify__<T>(value: T): Promise<T>;
+    }
+    function clearImmediate(immediateId: NodeJS.Immediate): void;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/trace_events.d.ts

+declare module "trace_events" {
+    /**
+     * The `Tracing` object is used to enable or disable tracing for sets of
+     * categories. Instances are created using the
+     * `trace_events.createTracing()` method.
+     *
+     * When created, the `Tracing` object is disabled. Calling the
+     * `tracing.enable()` method adds the categories to the set of enabled trace
+     * event categories. Calling `tracing.disable()` will remove the categories
+     * from the set of enabled trace event categories.
+     */
+    interface Tracing {
+        /**
+         * A comma-separated list of the trace event categories covered by this
+         * `Tracing` object.
+         */
+        readonly categories: string;
+
+        /**
+         * Disables this `Tracing` object.
+         *
+         * Only trace event categories _not_ covered by other enabled `Tracing`
+         * objects and _not_ specified by the `--trace-event-categories` flag
+         * will be disabled.
+         */
+        disable(): void;
+
+        /**
+         * Enables this `Tracing` object for the set of categories covered by
+         * the `Tracing` object.
+         */
+        enable(): void;
+
+        /**
+         * `true` only if the `Tracing` object has been enabled.
+         */
+        readonly enabled: boolean;
+    }
+
+    interface CreateTracingOptions {
+        /**
+         * An array of trace category names. Values included in the array are
+         * coerced to a string when possible. An error will be thrown if the
+         * value cannot be coerced.
+         */
+        categories: string[];
+    }
+
+    /**
+     * Creates and returns a Tracing object for the given set of categories.
+     */
+    function createTracing(options: CreateTracingOptions): Tracing;
+
+    /**
+     * Returns a comma-separated list of all currently-enabled trace event
+     * categories. The current set of enabled trace event categories is
+     * determined by the union of all currently-enabled `Tracing` objects and
+     * any categories enabled using the `--trace-event-categories` flag.
+     */
+    function getEnabledCategories(): string | undefined;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/ts3.2/fs.d.ts

+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../fs.d.ts" />
+
+declare module 'fs' {
+    interface BigIntStats extends StatsBase<BigInt> {
+    }
+
+    class BigIntStats {
+        atimeNs: BigInt;
+        mtimeNs: BigInt;
+        ctimeNs: BigInt;
+        birthtimeNs: BigInt;
+    }
+
+    interface BigIntOptions {
+        bigint: true;
+    }
+
+    interface StatOptions {
+        bigint: boolean;
+    }
+
+    function stat(path: PathLike, options: BigIntOptions, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void): void;
+    function stat(path: PathLike, options: StatOptions, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+
+    namespace stat {
+        function __promisify__(path: PathLike, options: BigIntOptions): Promise<BigIntStats>;
+        function __promisify__(path: PathLike, options: StatOptions): Promise<Stats | BigIntStats>;
+    }
+
+    function statSync(path: PathLike, options: BigIntOptions): BigIntStats;
+    function statSync(path: PathLike, options: StatOptions): Stats | BigIntStats;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/ts3.2/globals.d.ts

+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../globals.d.ts" />
+
+declare namespace NodeJS {
+    interface HRTime {
+        bigint(): bigint;
+    }
+}
+
+interface Buffer extends Uint8Array {
+    readBigUInt64BE(offset?: number): bigint;
+    readBigUInt64LE(offset?: number): bigint;
+    readBigInt64BE(offset?: number): bigint;
+    readBigInt64LE(offset?: number): bigint;
+    writeBigInt64BE(value: bigint, offset?: number): number;
+    writeBigInt64LE(value: bigint, offset?: number): number;
+    writeBigUInt64BE(value: bigint, offset?: number): number;
+    writeBigUInt64LE(value: bigint, offset?: number): number;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/ts3.2/index.d.ts

+// NOTE: These definitions support NodeJS and TypeScript 3.2.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.2/index.d.ts  - Definitions specific to TypeScript 3.2
+
+// Reference required types from the default lib:
+/// <reference lib="es2018" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="esnext.intl" />
+/// <reference lib="esnext.bigint" />
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../base.d.ts" />
+
+// TypeScript 3.2-specific augmentations:
+/// <reference path="fs.d.ts" />
+/// <reference path="util.d.ts" />
+/// <reference path="globals.d.ts" />

bigdata/node_modules/_@types_node@12.12.9@@types/node/ts3.2/util.d.ts

+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../util.d.ts" />
+
+declare module "util" {
+    namespace inspect {
+        const custom: unique symbol;
+    }
+    namespace promisify {
+        const custom: unique symbol;
+    }
+    namespace types {
+        function isBigInt64Array(value: any): value is BigInt64Array;
+        function isBigUint64Array(value: any): value is BigUint64Array;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/tty.d.ts

+declare module "tty" {
+    import * as net from "net";
+
+    function isatty(fd: number): boolean;
+    class ReadStream extends net.Socket {
+        constructor(fd: number, options?: net.SocketConstructorOpts);
+        isRaw: boolean;
+        setRawMode(mode: boolean): void;
+        isTTY: boolean;
+    }
+    /**
+     * -1 - to the left from cursor
+     *  0 - the entire line
+     *  1 - to the right from cursor
+     */
+    type Direction = -1 | 0 | 1;
+    class WriteStream extends net.Socket {
+        constructor(fd: number);
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "resize", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "resize"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "resize", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "resize", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "resize", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "resize", listener: () => void): this;
+
+        /**
+         * Clears the current line of this WriteStream in a direction identified by `dir`.
+         */
+        clearLine(dir: Direction, callback?: () => void): boolean;
+        /**
+         * Clears this `WriteStream` from the current cursor down.
+         */
+        clearScreenDown(callback?: () => void): boolean;
+        /**
+         * Moves this WriteStream's cursor to the specified position.
+         */
+        cursorTo(x: number, y?: number, callback?: () => void): boolean;
+        cursorTo(x: number, callback: () => void): boolean;
+        /**
+         * Moves this WriteStream's cursor relative to its current position.
+         */
+        moveCursor(dx: number, dy: number, callback?: () => void): boolean;
+        /**
+         * @default `process.env`
+         */
+        getColorDepth(env?: {}): number;
+        hasColors(depth?: number): boolean;
+        hasColors(env?: {}): boolean;
+        hasColors(depth: number, env?: {}): boolean;
+        getWindowSize(): [number, number];
+        columns: number;
+        rows: number;
+        isTTY: boolean;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/url.d.ts

+declare module "url" {
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
+
+    // Input to `url.format`
+    interface UrlObject {
+        auth?: string | null;
+        hash?: string | null;
+        host?: string | null;
+        hostname?: string | null;
+        href?: string | null;
+        path?: string | null;
+        pathname?: string | null;
+        protocol?: string | null;
+        search?: string | null;
+        slashes?: boolean | null;
+        port?: string | number | null;
+        query?: string | null | ParsedUrlQueryInput;
+    }
+
+    // Output of `url.parse`
+    interface Url {
+        auth: string | null;
+        hash: string | null;
+        host: string | null;
+        hostname: string | null;
+        href: string;
+        path: string | null;
+        pathname: string | null;
+        protocol: string | null;
+        search: string | null;
+        slashes: boolean | null;
+        port: string | null;
+        query: string | null | ParsedUrlQuery;
+    }
+
+    interface UrlWithParsedQuery extends Url {
+        query: ParsedUrlQuery;
+    }
+
+    interface UrlWithStringQuery extends Url {
+        query: string | null;
+    }
+
+    function parse(urlStr: string): UrlWithStringQuery;
+    function parse(urlStr: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
+    function parse(urlStr: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
+    function parse(urlStr: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
+
+    function format(URL: URL, options?: URLFormatOptions): string;
+    function format(urlObject: UrlObject | string): string;
+    function resolve(from: string, to: string): string;
+
+    function domainToASCII(domain: string): string;
+    function domainToUnicode(domain: string): string;
+
+    /**
+     * This function ensures the correct decodings of percent-encoded characters as
+     * well as ensuring a cross-platform valid absolute path string.
+     * @param url The file URL string or URL object to convert to a path.
+     */
+    function fileURLToPath(url: string | URL): string;
+
+    /**
+     * This function ensures that path is resolved absolutely, and that the URL
+     * control characters are correctly encoded when converting into a File URL.
+     * @param url The path to convert to a File URL.
+     */
+    function pathToFileURL(url: string): URL;
+
+    interface URLFormatOptions {
+        auth?: boolean;
+        fragment?: boolean;
+        search?: boolean;
+        unicode?: boolean;
+    }
+
+    class URL {
+        constructor(input: string, base?: string | URL);
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: URLSearchParams;
+        username: string;
+        toString(): string;
+        toJSON(): string;
+    }
+
+    class URLSearchParams implements Iterable<[string, string]> {
+        constructor(init?: URLSearchParams | string | { [key: string]: string | string[] | undefined } | Iterable<[string, string]> | Array<[string, string]>);
+        append(name: string, value: string): void;
+        delete(name: string): void;
+        entries(): IterableIterator<[string, string]>;
+        forEach(callback: (value: string, name: string, searchParams: this) => void): void;
+        get(name: string): string | null;
+        getAll(name: string): string[];
+        has(name: string): boolean;
+        keys(): IterableIterator<string>;
+        set(name: string, value: string): void;
+        sort(): void;
+        toString(): string;
+        values(): IterableIterator<string>;
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+    }
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/v8.d.ts

+declare module "v8" {
+    import { Readable } from "stream";
+
+    interface HeapSpaceInfo {
+        space_name: string;
+        space_size: number;
+        space_used_size: number;
+        space_available_size: number;
+        physical_space_size: number;
+    }
+
+    // ** Signifies if the --zap_code_space option is enabled or not.  1 == enabled, 0 == disabled. */
+    type DoesZapCodeSpaceFlag = 0 | 1;
+
+    interface HeapInfo {
+        total_heap_size: number;
+        total_heap_size_executable: number;
+        total_physical_size: number;
+        total_available_size: number;
+        used_heap_size: number;
+        heap_size_limit: number;
+        malloced_memory: number;
+        peak_malloced_memory: number;
+        does_zap_garbage: DoesZapCodeSpaceFlag;
+        number_of_native_contexts: number;
+        number_of_detached_contexts: number;
+    }
+
+    interface HeapCodeStatistics {
+        code_and_metadata_size: number;
+        bytecode_and_metadata_size: number;
+        external_script_source_size: number;
+    }
+
+    /**
+     * Returns an integer representing a "version tag" derived from the V8 version, command line flags and detected CPU features.
+     * This is useful for determining whether a vm.Script cachedData buffer is compatible with this instance of V8.
+     */
+    function cachedDataVersionTag(): number;
+
+    function getHeapStatistics(): HeapInfo;
+    function getHeapSpaceStatistics(): HeapSpaceInfo[];
+    function setFlagsFromString(flags: string): void;
+    /**
+     * Generates a snapshot of the current V8 heap and returns a Readable
+     * Stream that may be used to read the JSON serialized representation.
+     * This conversation was marked as resolved by joyeecheung
+     * This JSON stream format is intended to be used with tools such as
+     * Chrome DevTools. The JSON schema is undocumented and specific to the
+     * V8 engine, and may change from one version of V8 to the next.
+     */
+    function getHeapSnapshot(): Readable;
+
+    /**
+     *
+     * @param fileName The file path where the V8 heap snapshot is to be
+     * saved. If not specified, a file name with the pattern
+     * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
+     * generated, where `{pid}` will be the PID of the Node.js process,
+     * `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from
+     * the main Node.js thread or the id of a worker thread.
+     */
+    function writeHeapSnapshot(fileName?: string): string;
+
+    function getHeapCodeStatistics(): HeapCodeStatistics;
+
+    /**
+     * @experimental
+     */
+    class Serializer {
+        /**
+         * Writes out a header, which includes the serialization format version.
+         */
+        writeHeader(): void;
+
+        /**
+         * Serializes a JavaScript value and adds the serialized representation to the internal buffer.
+         * This throws an error if value cannot be serialized.
+         */
+        writeValue(val: any): boolean;
+
+        /**
+         * Returns the stored internal buffer.
+         * This serializer should not be used once the buffer is released.
+         * Calling this method results in undefined behavior if a previous write has failed.
+         */
+        releaseBuffer(): Buffer;
+
+        /**
+         * Marks an ArrayBuffer as having its contents transferred out of band.\
+         * Pass the corresponding ArrayBuffer in the deserializing context to deserializer.transferArrayBuffer().
+         */
+        transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+
+        /**
+         * Write a raw 32-bit unsigned integer.
+         */
+        writeUint32(value: number): void;
+
+        /**
+         * Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
+         */
+        writeUint64(hi: number, lo: number): void;
+
+        /**
+         * Write a JS number value.
+         */
+        writeDouble(value: number): void;
+
+        /**
+         * Write raw bytes into the serializer’s internal buffer.
+         * The deserializer will require a way to compute the length of the buffer.
+         */
+        writeRawBytes(buffer: NodeJS.TypedArray): void;
+    }
+
+    /**
+     * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
+     * and only stores the part of their underlying `ArrayBuffers` that they are referring to.
+     * @experimental
+     */
+    class DefaultSerializer extends Serializer {
+    }
+
+    /**
+     * @experimental
+     */
+    class Deserializer {
+        constructor(data: NodeJS.TypedArray);
+        /**
+         * Reads and validates a header (including the format version).
+         * May, for example, reject an invalid or unsupported wire format.
+         * In that case, an Error is thrown.
+         */
+        readHeader(): boolean;
+
+        /**
+         * Deserializes a JavaScript value from the buffer and returns it.
+         */
+        readValue(): any;
+
+        /**
+         * Marks an ArrayBuffer as having its contents transferred out of band.
+         * Pass the corresponding `ArrayBuffer` in the serializing context to serializer.transferArrayBuffer()
+         * (or return the id from serializer._getSharedArrayBufferId() in the case of SharedArrayBuffers).
+         */
+        transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
+
+        /**
+         * Reads the underlying wire format version.
+         * Likely mostly to be useful to legacy code reading old wire format versions.
+         * May not be called before .readHeader().
+         */
+        getWireFormatVersion(): number;
+
+        /**
+         * Read a raw 32-bit unsigned integer and return it.
+         */
+        readUint32(): number;
+
+        /**
+         * Read a raw 64-bit unsigned integer and return it as an array [hi, lo] with two 32-bit unsigned integer entries.
+         */
+        readUint64(): [number, number];
+
+        /**
+         * Read a JS number value.
+         */
+        readDouble(): number;
+
+        /**
+         * Read raw bytes from the deserializer’s internal buffer.
+         * The length parameter must correspond to the length of the buffer that was passed to serializer.writeRawBytes().
+         */
+        readRawBytes(length: number): Buffer;
+    }
+
+    /**
+     * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
+     * and only stores the part of their underlying `ArrayBuffers` that they are referring to.
+     * @experimental
+     */
+    class DefaultDeserializer extends Deserializer {
+    }
+
+    /**
+     * Uses a `DefaultSerializer` to serialize value into a buffer.
+     * @experimental
+     */
+    function serialize(value: any): Buffer;
+
+    /**
+     * Uses a `DefaultDeserializer` with default options to read a JS value from a buffer.
+     * @experimental
+     */
+    function deserialize(data: NodeJS.TypedArray): any;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/vm.d.ts

+declare module "vm" {
+    interface Context {
+        [key: string]: any;
+    }
+    interface BaseOptions {
+        /**
+         * Specifies the filename used in stack traces produced by this script.
+         * Default: `''`.
+         */
+        filename?: string;
+        /**
+         * Specifies the line number offset that is displayed in stack traces produced by this script.
+         * Default: `0`.
+         */
+        lineOffset?: number;
+        /**
+         * Specifies the column number offset that is displayed in stack traces produced by this script.
+         * Default: `0`
+         */
+        columnOffset?: number;
+    }
+    interface ScriptOptions extends BaseOptions {
+        displayErrors?: boolean;
+        timeout?: number;
+        cachedData?: Buffer;
+        produceCachedData?: boolean;
+    }
+    interface RunningScriptOptions extends BaseOptions {
+        /**
+         * When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace.
+         * Default: `true`.
+         */
+        displayErrors?: boolean;
+        /**
+         * Specifies the number of milliseconds to execute code before terminating execution.
+         * If execution is terminated, an `Error` will be thrown. This value must be a strictly positive integer.
+         */
+        timeout?: number;
+        /**
+         * If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received.
+         * Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that.
+         * If execution is terminated, an `Error` will be thrown.
+         * Default: `false`.
+         */
+        breakOnSigint?: boolean;
+    }
+    interface CompileFunctionOptions extends BaseOptions {
+        /**
+         * Provides an optional data with V8's code cache data for the supplied source.
+         */
+        cachedData?: Buffer;
+        /**
+         * Specifies whether to produce new cache data.
+         * Default: `false`,
+         */
+        produceCachedData?: boolean;
+        /**
+         * The sandbox/context in which the said function should be compiled in.
+         */
+        parsingContext?: Context;
+
+        /**
+         * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
+         */
+        contextExtensions?: Object[];
+    }
+
+    interface CreateContextOptions {
+        /**
+         * Human-readable name of the newly created context.
+         * @default 'VM Context i' Where i is an ascending numerical index of the created context.
+         */
+        name?: string;
+        /**
+         * Corresponds to the newly created context for display purposes.
+         * The origin should be formatted like a `URL`, but with only the scheme, host, and port (if necessary),
+         * like the value of the `url.origin` property of a URL object.
+         * Most notably, this string should omit the trailing slash, as that denotes a path.
+         * @default ''
+         */
+        origin?: string;
+        codeGeneration?: {
+            /**
+             * If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
+             * will throw an EvalError.
+             * @default true
+             */
+            strings?: boolean;
+            /**
+             * If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
+             * @default true
+             */
+            wasm?: boolean;
+        };
+    }
+
+    class Script {
+        constructor(code: string, options?: ScriptOptions);
+        runInContext(contextifiedSandbox: Context, options?: RunningScriptOptions): any;
+        runInNewContext(sandbox?: Context, options?: RunningScriptOptions): any;
+        runInThisContext(options?: RunningScriptOptions): any;
+        createCachedData(): Buffer;
+    }
+    function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
+    function isContext(sandbox: Context): boolean;
+    function runInContext(code: string, contextifiedSandbox: Context, options?: RunningScriptOptions | string): any;
+    function runInNewContext(code: string, sandbox?: Context, options?: RunningScriptOptions | string): any;
+    function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
+    function compileFunction(code: string, params: string[], options: CompileFunctionOptions): Function;
+}

bigdata/node_modules/_@types_node@12.12.9@@types/node/worker_threads.d.ts

+declare module "worker_threads" {
+    import { Context } from "vm";
+    import { EventEmitter } from "events";
+    import { Readable, Writable } from "stream";
+
+    const isMainThread: boolean;
+    const parentPort: null | MessagePort;
+    const threadId: number;
+    const workerData: any;
+
+    class MessageChannel {
+        readonly port1: MessagePort;
+        readonly port2: MessagePort;
+    }
+
+    class MessagePort extends EventEmitter {
+        close(): void;
+        postMessage(value: any, transferList?: Array<ArrayBuffer | MessagePort>): void;
+        ref(): void;
+        unref(): void;
+        start(): void;
+
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        emit(event: "close"): boolean;
+        emit(event: "message", value: any): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+
+        on(event: "close", listener: () => void): this;
+        on(event: "message", listener: (value: any) => void): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        once(event: "close", listener: () => void): this;
+        once(event: "message", listener: (value: any) => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeListener(event: "close", listener: () => void): this;
+        removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        off(event: "close", listener: () => void): this;
+        off(event: "message", listener: (value: any) => void): this;
+        off(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+
+    interface WorkerOptions {
+        eval?: boolean;
+        workerData?: any;
+        stdin?: boolean;
+        stdout?: boolean;
+        stderr?: boolean;
+        execArgv?: string[];
+    }
+
+    class Worker extends EventEmitter {
+        readonly stdin: Writable | null;
+        readonly stdout: Readable;
+        readonly stderr: Readable;
+        readonly threadId: number;
+
+        constructor(filename: string, options?: WorkerOptions);
+
+        postMessage(value: any, transferList?: Array<ArrayBuffer | MessagePort>): void;
+        ref(): void;
+        unref(): void;
+        /**
+         * Stop all JavaScript execution in the worker thread as soon as possible.
+         * Returns a Promise for the exit code that is fulfilled when the `exit` event is emitted.
+         */
+        terminate(): Promise<number>;
+        /**
+         * Transfer a `MessagePort` to a different `vm` Context. The original `port`
+         * object will be rendered unusable, and the returned `MessagePort` instance will
+         * take its place.
+         *
+         * The returned `MessagePort` will be an object in the target context, and will
+         * inherit from its global `Object` class. Objects passed to the
+         * `port.onmessage()` listener will also be created in the target context
+         * and inherit from its global `Object` class.
+         *
+         * However, the created `MessagePort` will no longer inherit from
+         * `EventEmitter`, and only `port.onmessage()` can be used to receive
+         * events using it.
+         */
+        moveMessagePortToContext(port: MessagePort, context: Context): MessagePort;
+
+        /**
+         * Receive a single message from a given `MessagePort`. If no message is available,
+         * `undefined` is returned, otherwise an object with a single `message` property
+         * that contains the message payload, corresponding to the oldest message in the
+         * `MessagePort`’s queue.
+         */
+        receiveMessageOnPort(port: MessagePort): {} | undefined;
+
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "exit", listener: (exitCode: number) => void): this;
+        addListener(event: "message", listener: (value: any) => void): this;
+        addListener(event: "online", listener: () => void): this;
+        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        emit(event: "error", err: Error): boolean;
+        emit(event: "exit", exitCode: number): boolean;
+        emit(event: "message", value: any): boolean;
+        emit(event: "online"): boolean;
+        emit(event: string | symbol, ...args: any[]): boolean;
+
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "exit", listener: (exitCode: number) => void): this;
+        on(event: "message", listener: (value: any) => void): this;
+        on(event: "online", listener: () => void): this;
+        on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "exit", listener: (exitCode: number) => void): this;
+        once(event: "message", listener: (value: any) => void): this;
+        once(event: "online", listener: () => void): this;
+        once(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "exit", listener: (exitCode: number) => void): this;
+        prependListener(event: "message", listener: (value: any) => void): this;
+        prependListener(event: "online", listener: () => void): this;
+        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
+        prependOnceListener(event: "message", listener: (value: any) => void): this;
+        prependOnceListener(event: "online", listener: () => void): this;
+        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        removeListener(event: "error", listener: (err: Error) => void): this;
+        removeListener(event: "exit", listener: (exitCode: number) => void): this;
+        removeListener(event: "message", listener: (value: any) => void): this;
+        removeListener(event: "online", listener: () => void): this;
+        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+        off(event: "error", listener: (err: Error) => void): this;
+        off(event: "exit", listener: (exitCode: number) => void): this;
+        off(event: "message", listener: (value: any) => void): this;
+        off(event: "online", listener: () => void): this;
+        off(event: string | symbol, listener: (...args: any[]) => void): this;
+    }
+}

bigdata/node_modules/_MD5@1.3.0@MD5/.npmignore

+node_modules/mocha

bigdata/node_modules/_MD5@1.3.0@MD5/.travis.yml

+language: node_js
+node_js:
+  - 0.6
+  - 0.8
\ No newline at end of file

bigdata/node_modules/_MD5@1.3.0@MD5/LICENSE

+Copyright © 2011-2012, Paul Vorbach.
+Copyright © 2009, Jeff Mott.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name Crypto-JS nor the names of its contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

bigdata/node_modules/_MD5@1.3.0@MD5/README.md

+# MD5
+
+**TL;DR:** _This module is deprecated, use lowercase md5@>=2.x from now on._
+
+For years, there has been a lot of confusion with this module since there were
+two MD5 modules on npm, one called ["MD5"](https://www.npmjs.com/package/MD5)
+(uppercase, the module you are looking at) as well as [one by AJ ONeal called
+"md5"](https://github.com/coolaj86/jsMD5) (lowercase). With version 2.0.0, only
+the implementation in this git repository stays on NPM, but its name changes
+from uppercase to lowercase. Old versions of both modules are marked deprecated.
+From now on, please use lowercase md5 with versions >= 2.0.0.
+
+## License
+
+~~~
+Copyright © 2011-2012, Paul Vorbach.
+Copyright © 2009, Jeff Mott.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name Crypto-JS nor the names of its contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+~~~

bigdata/node_modules/_MD5@1.3.0@MD5/md5.js

+(function(){
+  var crypt = require('crypt'),
+      utf8 = require('charenc').utf8,
+      bin = require('charenc').bin,
+
+  // The core
+  md5 = function (message, options) {
+    // Convert to byte array
+    if (message.constructor == String)
+      if (options && options.encoding === 'binary')
+        message = bin.stringToBytes(message);
+      else
+        message = utf8.stringToBytes(message);
+    else if (typeof Buffer != 'undefined' &&
+        typeof Buffer.isBuffer == 'function' && Buffer.isBuffer(message))
+      message = Array.prototype.slice.call(message, 0);
+    else if (!Array.isArray(message))
+      message = message.toString();
+    // else, assume byte array already
+
+    var m = crypt.bytesToWords(message),
+        l = message.length * 8,
+        a =  1732584193,
+        b = -271733879,
+        c = -1732584194,
+        d =  271733878;
+
+    // Swap endian
+    for (var i = 0; i < m.length; i++) {
+      m[i] = ((m[i] <<  8) | (m[i] >>> 24)) & 0x00FF00FF |
+             ((m[i] << 24) | (m[i] >>>  8)) & 0xFF00FF00;
+    }
+
+    // Padding
+    m[l >>> 5] |= 0x80 << (l % 32);
+    m[(((l + 64) >>> 9) << 4) + 14] = l;
+
+    // Method shortcuts
+    var FF = md5._ff,
+        GG = md5._gg,
+        HH = md5._hh,
+        II = md5._ii;
+
+    for (var i = 0; i < m.length; i += 16) {
+
+      var aa = a,
+          bb = b,
+          cc = c,
+          dd = d;
+
+      a = FF(a, b, c, d, m[i+ 0],  7, -680876936);
+      d = FF(d, a, b, c, m[i+ 1], 12, -389564586);
+      c = FF(c, d, a, b, m[i+ 2], 17,  606105819);
+      b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);
+      a = FF(a, b, c, d, m[i+ 4],  7, -176418897);
+      d = FF(d, a, b, c, m[i+ 5], 12,  1200080426);
+      c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);
+      b = FF(b, c, d, a, m[i+ 7], 22, -45705983);
+      a = FF(a, b, c, d, m[i+ 8],  7,  1770035416);
+      d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);
+      c = FF(c, d, a, b, m[i+10], 17, -42063);
+      b = FF(b, c, d, a, m[i+11], 22, -1990404162);
+      a = FF(a, b, c, d, m[i+12],  7,  1804603682);
+      d = FF(d, a, b, c, m[i+13], 12, -40341101);
+      c = FF(c, d, a, b, m[i+14], 17, -1502002290);
+      b = FF(b, c, d, a, m[i+15], 22,  1236535329);
+
+      a = GG(a, b, c, d, m[i+ 1],  5, -165796510);
+      d = GG(d, a, b, c, m[i+ 6],  9, -1069501632);
+      c = GG(c, d, a, b, m[i+11], 14,  643717713);
+      b = GG(b, c, d, a, m[i+ 0], 20, -373897302);
+      a = GG(a, b, c, d, m[i+ 5],  5, -701558691);
+      d = GG(d, a, b, c, m[i+10],  9,  38016083);
+      c = GG(c, d, a, b, m[i+15], 14, -660478335);
+      b = GG(b, c, d, a, m[i+ 4], 20, -405537848);
+      a = GG(a, b, c, d, m[i+ 9],  5,  568446438);
+      d = GG(d, a, b, c, m[i+14],  9, -1019803690);
+      c = GG(c, d, a, b, m[i+ 3], 14, -187363961);
+      b = GG(b, c, d, a, m[i+ 8], 20,  1163531501);
+      a = GG(a, b, c, d, m[i+13],  5, -1444681467);
+      d = GG(d, a, b, c, m[i+ 2],  9, -51403784);
+      c = GG(c, d, a, b, m[i+ 7], 14,  1735328473);
+      b = GG(b, c, d, a, m[i+12], 20, -1926607734);
+
+      a = HH(a, b, c, d, m[i+ 5],  4, -378558);
+      d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);
+      c = HH(c, d, a, b, m[i+11], 16,  1839030562);
+      b = HH(b, c, d, a, m[i+14], 23, -35309556);
+      a = HH(a, b, c, d, m[i+ 1],  4, -1530992060);
+      d = HH(d, a, b, c, m[i+ 4], 11,  1272893353);
+      c = HH(c, d, a, b, m[i+ 7], 16, -155497632);
+      b = HH(b, c, d, a, m[i+10], 23, -1094730640);
+      a = HH(a, b, c, d, m[i+13],  4,  681279174);
+      d = HH(d, a, b, c, m[i+ 0], 11, -358537222);
+      c = HH(c, d, a, b, m[i+ 3], 16, -722521979);
+      b = HH(b, c, d, a, m[i+ 6], 23,  76029189);
+      a = HH(a, b, c, d, m[i+ 9],  4, -640364487);
+      d = HH(d, a, b, c, m[i+12], 11, -421815835);
+      c = HH(c, d, a, b, m[i+15], 16,  530742520);
+      b = HH(b, c, d, a, m[i+ 2], 23, -995338651);
+
+      a = II(a, b, c, d, m[i+ 0],  6, -198630844);
+      d = II(d, a, b, c, m[i+ 7], 10,  1126891415);
+      c = II(c, d, a, b, m[i+14], 15, -1416354905);
+      b = II(b, c, d, a, m[i+ 5], 21, -57434055);
+      a = II(a, b, c, d, m[i+12],  6,  1700485571);
+      d = II(d, a, b, c, m[i+ 3], 10, -1894986606);
+      c = II(c, d, a, b, m[i+10], 15, -1051523);
+      b = II(b, c, d, a, m[i+ 1], 21, -2054922799);
+      a = II(a, b, c, d, m[i+ 8],  6,  1873313359);
+      d = II(d, a, b, c, m[i+15], 10, -30611744);
+      c = II(c, d, a, b, m[i+ 6], 15, -1560198380);
+      b = II(b, c, d, a, m[i+13], 21,  1309151649);
+      a = II(a, b, c, d, m[i+ 4],  6, -145523070);
+      d = II(d, a, b, c, m[i+11], 10, -1120210379);
+      c = II(c, d, a, b, m[i+ 2], 15,  718787259);
+      b = II(b, c, d, a, m[i+ 9], 21, -343485551);
+
+      a = (a + aa) >>> 0;
+      b = (b + bb) >>> 0;
+      c = (c + cc) >>> 0;
+      d = (d + dd) >>> 0;
+    }
+
+    return crypt.endian([a, b, c, d]);
+  };
+
+  // Auxiliary functions
+  md5._ff  = function (a, b, c, d, x, s, t) {
+    var n = a + (b & c | ~b & d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+  md5._gg  = function (a, b, c, d, x, s, t) {
+    var n = a + (b & d | c & ~d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+  md5._hh  = function (a, b, c, d, x, s, t) {
+    var n = a + (b ^ c ^ d) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+  md5._ii  = function (a, b, c, d, x, s, t) {
+    var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+    return ((n << s) | (n >>> (32 - s))) + b;
+  };
+
+  // Package private blocksize
+  md5._blocksize = 16;
+  md5._digestsize = 16;
+
+  module.exports = function (message, options) {
+    if(typeof message == 'undefined')
+      return;
+
+    var digestbytes = crypt.wordsToBytes(md5(message, options));
+    return options && options.asBytes ? digestbytes :
+        options && options.asString ? bin.bytesToString(digestbytes) :
+        crypt.bytesToHex(digestbytes);
+  };
+
+})();

bigdata/node_modules/_MD5@1.3.0@MD5/node_modules/charenc

+../../_charenc@0.0.2@charenc
\ No newline at end of file

bigdata/node_modules/_MD5@1.3.0@MD5/node_modules/crypt

+../../_crypt@0.0.2@crypt
\ No newline at end of file

bigdata/node_modules/_MD5@1.3.0@MD5/package.json

+{
+  "author": "Paul Vorbach <paul@vorb.de> (http://vorb.de)",
+  "contributors": [
+    "salba"
+  ],
+  "name": "MD5",
+  "description": "native js function for hashing messages with MD5 (deprecated, use lowercase md5@>=2.x from now on)",
+  "tags": [
+    "md5",
+    "hash",
+    "encryption",
+    "native",
+    "message digest"
+  ],
+  "version": "1.3.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/pvorb/node-md5.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pvorb/node-md5/issues"
+  },
+  "main": "md5.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {
+    "charenc": ">= 0.0.1",
+    "crypt": ">= 0.0.1"
+  },
+  "devDependencies": {
+    "mocha": "~ 1.4.2"
+  },
+  "optionalDependencies": {},
+  "license": "BSD-3-Clause",
+  "__npminstall_done": "Tue Nov 19 2019 17:18:34 GMT+0800 (CST)",
+  "_from": "MD5@1.3.0",
+  "_resolved": "https://registry.npm.taobao.org/MD5/download/MD5-1.3.0.tgz"
+}
\ No newline at end of file

bigdata/node_modules/_MD5@1.3.0@MD5/test.js

+var md5 = require('./md5.js');
+var assert = require('assert');
+
+describe('MD5', function () {
+  it('should return the expected MD5 hash for "message"', function () {
+    assert.equal('78e731027d8fd50ed642340b7c9a63b3', md5('message'));
+  });
+
+  it('should not return the same hash for random numbers twice', function () {
+    var msg1 = Math.floor((Math.random() * 100000) + 1) + (new Date).getTime();
+    var msg2 = Math.floor((Math.random() * 100000) + 1) + (new Date).getTime();
+
+    if (msg1 !== msg2)
+      assert.notEqual(md5(msg1), md5(msg2));
+    else
+      assert.equal(md5(msg1), md5(msg1));
+  });
+
+  it('should support Node.js Buffers', function() {
+    var buffer = new Buffer('message áßäöü', 'utf8');
+
+    assert.equal(md5(buffer), md5('message áßäöü'));
+  })
+
+  it('should be able to use a binary encoded string', function () {
+    var hash1 = md5('abc', { asString: true });
+    var hash2 = md5(hash1 + 'a', { asString: true, encoding : 'binary' });
+    var hash3 = md5(hash1 + 'a', { encoding : 'binary' });
+    // console.log('hash1', hash1);
+    // console.log('hash2', hash2);
+    // console.log('hash3', hash3);
+    assert.equal(hash3, '131f0ac52813044f5110e4aec638c169');
+  });
+});

bigdata/node_modules/_abbrev@1.1.1@abbrev/LICENSE

+This software is dual-licensed under the ISC and MIT licenses.
+You may use this software under EITHER of the following licenses.
+
+----------
+
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+----------
+
+Copyright Isaac Z. Schlueter and Contributors
+All rights reserved.
+
+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.

bigdata/node_modules/_abbrev@1.1.1@abbrev/README.md

+# abbrev-js
+
+Just like [ruby's Abbrev](http://apidock.com/ruby/Abbrev).
+
+Usage:
+
+    var abbrev = require("abbrev");
+    abbrev("foo", "fool", "folding", "flop");
+    
+    // returns:
+    { fl: 'flop'
+    , flo: 'flop'
+    , flop: 'flop'
+    , fol: 'folding'
+    , fold: 'folding'
+    , foldi: 'folding'
+    , foldin: 'folding'
+    , folding: 'folding'
+    , foo: 'foo'
+    , fool: 'fool'
+    }
+
+This is handy for command-line scripts, or other cases where you want to be able to accept shorthands.

bigdata/node_modules/_abbrev@1.1.1@abbrev/abbrev.js

+module.exports = exports = abbrev.abbrev = abbrev
+
+abbrev.monkeyPatch = monkeyPatch
+
+function monkeyPatch () {
+  Object.defineProperty(Array.prototype, 'abbrev', {
+    value: function () { return abbrev(this) },
+    enumerable: false, configurable: true, writable: true
+  })
+
+  Object.defineProperty(Object.prototype, 'abbrev', {
+    value: function () { return abbrev(Object.keys(this)) },
+    enumerable: false, configurable: true, writable: true
+  })
+}
+
+function abbrev (list) {
+  if (arguments.length !== 1 || !Array.isArray(list)) {
+    list = Array.prototype.slice.call(arguments, 0)
+  }
+  for (var i = 0, l = list.length, args = [] ; i < l ; i ++) {
+    args[i] = typeof list[i] === "string" ? list[i] : String(list[i])
+  }
+
+  // sort them lexicographically, so that they're next to their nearest kin
+  args = args.sort(lexSort)
+
+  // walk through each, seeing how much it has in common with the next and previous
+  var abbrevs = {}
+    , prev = ""
+  for (var i = 0, l = args.length ; i < l ; i ++) {
+    var current = args[i]
+      , next = args[i + 1] || ""
+      , nextMatches = true
+      , prevMatches = true
+    if (current === next) continue
+    for (var j = 0, cl = current.length ; j < cl ; j ++) {
+      var curChar = current.charAt(j)
+      nextMatches = nextMatches && curChar === next.charAt(j)
+      prevMatches = prevMatches && curChar === prev.charAt(j)
+      if (!nextMatches && !prevMatches) {
+        j ++
+        break
+      }
+    }
+    prev = current
+    if (j === cl) {
+      abbrevs[current] = current
+      continue
+    }
+    for (var a = current.substr(0, j) ; j <= cl ; j ++) {
+      abbrevs[a] = current
+      a += current.charAt(j)
+    }
+  }
+  return abbrevs
+}
+
+function lexSort (a, b) {
+  return a === b ? 0 : a > b ? 1 : -1
+}

bigdata/node_modules/_abbrev@1.1.1@abbrev/package.json

+{
+  "name": "abbrev",
+  "version": "1.1.1",
+  "description": "Like ruby's abbrev module, but in js",
+  "author": "Isaac Z. Schlueter <i@izs.me>",
+  "main": "abbrev.js",
+  "scripts": {
+    "test": "tap test.js --100",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --all; git push origin --tags"
+  },
+  "repository": "http://github.com/isaacs/abbrev-js",
+  "license": "ISC",
+  "devDependencies": {
+    "tap": "^10.1"
+  },
+  "files": [
+    "abbrev.js"
+  ],
+  "__npminstall_done": "Tue Nov 19 2019 17:18:36 GMT+0800 (CST)",
+  "_from": "abbrev@1.1.1",
+  "_resolved": "https://registry.npm.taobao.org/abbrev/download/abbrev-1.1.1.tgz"
+}
\ No newline at end of file

bigdata/node_modules/_accepts@1.3.7@accepts/HISTORY.md

+1.3.7 / 2019-04-29
+==================
+
+  * deps: negotiator@0.6.2
+    - Fix sorting charset, encoding, and language with extra parameters
+
+1.3.6 / 2019-04-28
+==================
+
+  * deps: mime-types@~2.1.24
+    - deps: mime-db@~1.40.0
+
+1.3.5 / 2018-02-28
+==================
+
+  * deps: mime-types@~2.1.18
+    - deps: mime-db@~1.33.0
+
+1.3.4 / 2017-08-22
+==================
+
+  * deps: mime-types@~2.1.16
+    - deps: mime-db@~1.29.0
+
+1.3.3 / 2016-05-02
+==================
+
+  * deps: mime-types@~2.1.11
+    - deps: mime-db@~1.23.0
+  * deps: negotiator@0.6.1
+    - perf: improve `Accept` parsing speed
+    - perf: improve `Accept-Charset` parsing speed
+    - perf: improve `Accept-Encoding` parsing speed
+    - perf: improve `Accept-Language` parsing speed
+
+1.3.2 / 2016-03-08
+==================
+
+  * deps: mime-types@~2.1.10
+    - Fix extension of `application/dash+xml`
+    - Update primary extension for `audio/mp4`
+    - deps: mime-db@~1.22.0
+
+1.3.1 / 2016-01-19
+==================
+
+  * deps: mime-types@~2.1.9
+    - deps: mime-db@~1.21.0
+
+1.3.0 / 2015-09-29
+==================
+
+  * deps: mime-types@~2.1.7
+    - deps: mime-db@~1.19.0
+  * deps: negotiator@0.6.0
+    - Fix including type extensions in parameters in `Accept` parsing
+    - Fix parsing `Accept` parameters with quoted equals
+    - Fix parsing `Accept` parameters with quoted semicolons
+    - Lazy-load modules from main entry point
+    - perf: delay type concatenation until needed
+    - perf: enable strict mode
+    - perf: hoist regular expressions
+    - perf: remove closures getting spec properties
+    - perf: remove a closure from media type parsing
+    - perf: remove property delete from media type parsing
+
+1.2.13 / 2015-09-06
+===================
+
+  * deps: mime-types@~2.1.6
+    - deps: mime-db@~1.18.0
+
+1.2.12 / 2015-07-30
+===================
+
+  * deps: mime-types@~2.1.4
+    - deps: mime-db@~1.16.0
+
+1.2.11 / 2015-07-16
+===================
+
+  * deps: mime-types@~2.1.3
+    - deps: mime-db@~1.15.0
+
+1.2.10 / 2015-07-01
+===================
+
+  * deps: mime-types@~2.1.2
+    - deps: mime-db@~1.14.0
+
+1.2.9 / 2015-06-08
+==================
+
+  * deps: mime-types@~2.1.1
+    - perf: fix deopt during mapping
+
+1.2.8 / 2015-06-07
+==================
+
+  * deps: mime-types@~2.1.0
+    - deps: mime-db@~1.13.0
+  * perf: avoid argument reassignment & argument slice
+  * perf: avoid negotiator recursive construction
+  * perf: enable strict mode
+  * perf: remove unnecessary bitwise operator
+
+1.2.7 / 2015-05-10
+==================
+
+  * deps: negotiator@0.5.3
+    - Fix media type parameter matching to be case-insensitive
+
+1.2.6 / 2015-05-07
+==================
+
+  * deps: mime-types@~2.0.11
+    - deps: mime-db@~1.9.1
+  * deps: negotiator@0.5.2
+    - Fix comparing media types with quoted values
+    - Fix splitting media types with quoted commas
+
+1.2.5 / 2015-03-13
+==================
+
+  * deps: mime-types@~2.0.10
+    - deps: mime-db@~1.8.0
+
+1.2.4 / 2015-02-14
+==================
+
+  * Support Node.js 0.6
+  * deps: mime-types@~2.0.9
+    - deps: mime-db@~1.7.0
+  * deps: negotiator@0.5.1
+    - Fix preference sorting to be stable for long acceptable lists
+
+1.2.3 / 2015-01-31
+==================
+
+  * deps: mime-types@~2.0.8
+    - deps: mime-db@~1.6.0
+
+1.2.2 / 2014-12-30
+==================
+
+  * deps: mime-types@~2.0.7
+    - deps: mime-db@~1.5.0
+
+1.2.1 / 2014-12-30
+==================
+
+  * deps: mime-types@~2.0.5
+    - deps: mime-db@~1.3.1
+
+1.2.0 / 2014-12-19
+==================
+
+  * deps: negotiator@0.5.0
+    - Fix list return order when large accepted list
+    - Fix missing identity encoding when q=0 exists
+    - Remove dynamic building of Negotiator class
+
+1.1.4 / 2014-12-10
+==================
+
+  * deps: mime-types@~2.0.4
+    - deps: mime-db@~1.3.0
+
+1.1.3 / 2014-11-09
+==================
+
+  * deps: mime-types@~2.0.3
+    - deps: mime-db@~1.2.0
+
+1.1.2 / 2014-10-14
+==================
+
+  * deps: negotiator@0.4.9
+    - Fix error when media type has invalid parameter
+
+1.1.1 / 2014-09-28
+==================
+
+  * deps: mime-types@~2.0.2
+    - deps: mime-db@~1.1.0
+  * deps: negotiator@0.4.8
+    - Fix all negotiations to be case-insensitive
+    - Stable sort preferences of same quality according to client order
+
+1.1.0 / 2014-09-02
+==================
+
+  * update `mime-types`
+
+1.0.7 / 2014-07-04
+==================
+
+  * Fix wrong type returned from `type` when match after unknown extension
+
+1.0.6 / 2014-06-24
+==================
+
+  * deps: negotiator@0.4.7
+
+1.0.5 / 2014-06-20
+==================
+
+ * fix crash when unknown extension given
+
+1.0.4 / 2014-06-19
+==================
+
+  * use `mime-types`
+
+1.0.3 / 2014-06-11
+==================
+
+  * deps: negotiator@0.4.6
+    - Order by specificity when quality is the same
+
+1.0.2 / 2014-05-29
+==================
+
+  * Fix interpretation when header not in request
+  * deps: pin negotiator@0.4.5
+
+1.0.1 / 2014-01-18
+==================
+
+  * Identity encoding isn't always acceptable
+  * deps: negotiator@~0.4.0
+
+1.0.0 / 2013-12-27
+==================
+
+  * Genesis

bigdata/node_modules/_accepts@1.3.7@accepts/LICENSE

+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.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.

bigdata/node_modules/_accepts@1.3.7@accepts/README.md

+# accepts
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator).
+Extracted from [koa](https://www.npmjs.com/package/koa) for general use.
+
+In addition to negotiator, it allows:
+
+- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])`
+  as well as `('text/html', 'application/json')`.
+- Allows type shorthands such as `json`.
+- Returns `false` when no types match
+- Treats non-existent headers as `*`
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install accepts
+```
+
+## API
+
+<!-- eslint-disable no-unused-vars -->
+
+```js
+var accepts = require('accepts')
+```
+
+### accepts(req)
+
+Create a new `Accepts` object for the given `req`.
+
+#### .charset(charsets)
+
+Return the first accepted charset. If nothing in `charsets` is accepted,
+then `false` is returned.
+
+#### .charsets()
+
+Return the charsets that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .encoding(encodings)
+
+Return the first accepted encoding. If nothing in `encodings` is accepted,
+then `false` is returned.
+
+#### .encodings()
+
+Return the encodings that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .language(languages)
+
+Return the first accepted language. If nothing in `languages` is accepted,
+then `false` is returned.
+
+#### .languages()
+
+Return the languages that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .type(types)
+
+Return the first accepted type (and it is returned as the same text as what
+appears in the `types` array). If nothing in `types` is accepted, then `false`
+is returned.
+
+The `types` array can contain full MIME types or file extensions. Any value
+that is not a full MIME types is passed to `require('mime-types').lookup`.
+
+#### .types()
+
+Return the types that the request accepts, in the order of the client's
+preference (most preferred first).
+
+## Examples
+
+### Simple type negotiation
+
+This simple example shows how to use `accepts` to return a different typed
+respond body based on what the client wants to accept. The server lists it's
+preferences in order and will get back the best match between the client and
+server.
+
+```js
+var accepts = require('accepts')
+var http = require('http')
+
+function app (req, res) {
+  var accept = accepts(req)
+
+  // the order of this list is significant; should be server preferred order
+  switch (accept.type(['json', 'html'])) {
+    case 'json':
+      res.setHeader('Content-Type', 'application/json')
+      res.write('{"hello":"world!"}')
+      break
+    case 'html':
+      res.setHeader('Content-Type', 'text/html')
+      res.write('<b>hello, world!</b>')
+      break
+    default:
+      // the fallback is text/plain, so no need to specify it above
+      res.setHeader('Content-Type', 'text/plain')
+      res.write('hello, world!')
+      break
+  }
+
+  res.end()
+}
+
+http.createServer(app).listen(3000)
+```
+
+You can test this out with the cURL program:
+```sh
+curl -I -H'Accept: text/html' http://localhost:3000/
+```
+
+## License
+
+[MIT](LICENSE)
+
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/accepts/master
+[coveralls-url]: https://coveralls.io/r/jshttp/accepts?branch=master
+[node-version-image]: https://badgen.net/npm/node/accepts
+[node-version-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/accepts
+[npm-url]: https://npmjs.org/package/accepts
+[npm-version-image]: https://badgen.net/npm/v/accepts
+[travis-image]: https://badgen.net/travis/jshttp/accepts/master
+[travis-url]: https://travis-ci.org/jshttp/accepts

bigdata/node_modules/_accepts@1.3.7@accepts/index.js

+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var Negotiator = require('negotiator')
+var mime = require('mime-types')
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = Accepts
+
+/**
+ * Create a new Accepts object for the given req.
+ *
+ * @param {object} req
+ * @public
+ */
+
+function Accepts (req) {
+  if (!(this instanceof Accepts)) {
+    return new Accepts(req)
+  }
+
+  this.headers = req.headers
+  this.negotiator = new Negotiator(req)
+}
+
+/**
+ * Check if the given `type(s)` is acceptable, returning
+ * the best match when true, otherwise `undefined`, in which
+ * case you should respond with 406 "Not Acceptable".
+ *
+ * The `type` value may be a single mime type string
+ * such as "application/json", the extension name
+ * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+ * or array is given the _best_ match, if any is returned.
+ *
+ * Examples:
+ *
+ *     // Accept: text/html
+ *     this.types('html');
+ *     // => "html"
+ *
+ *     // Accept: text/*, application/json
+ *     this.types('html');
+ *     // => "html"
+ *     this.types('text/html');
+ *     // => "text/html"
+ *     this.types('json', 'text');
+ *     // => "json"
+ *     this.types('application/json');
+ *     // => "application/json"
+ *
+ *     // Accept: text/*, application/json
+ *     this.types('image/png');
+ *     this.types('png');
+ *     // => undefined
+ *
+ *     // Accept: text/*;q=.5, application/json
+ *     this.types(['html', 'json']);
+ *     this.types('html', 'json');
+ *     // => "json"
+ *
+ * @param {String|Array} types...
+ * @return {String|Array|Boolean}
+ * @public
+ */
+
+Accepts.prototype.type =
+Accepts.prototype.types = function (types_) {
+  var types = types_
+
+  // support flattened arguments
+  if (types && !Array.isArray(types)) {
+    types = new Array(arguments.length)
+    for (var i = 0; i < types.length; i++) {
+      types[i] = arguments[i]
+    }
+  }
+
+  // no types, return all requested types
+  if (!types || types.length === 0) {
+    return this.negotiator.mediaTypes()
+  }
+
+  // no accept header, return first given type
+  if (!this.headers.accept) {
+    return types[0]
+  }
+
+  var mimes = types.map(extToMime)
+  var accepts = this.negotiator.mediaTypes(mimes.filter(validMime))
+  var first = accepts[0]
+
+  return first
+    ? types[mimes.indexOf(first)]
+    : false
+}
+
+/**
+ * Return accepted encodings or best fit based on `encodings`.
+ *
+ * Given `Accept-Encoding: gzip, deflate`
+ * an array sorted by quality is returned:
+ *
+ *     ['gzip', 'deflate']
+ *
+ * @param {String|Array} encodings...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.encoding =
+Accepts.prototype.encodings = function (encodings_) {
+  var encodings = encodings_
+
+  // support flattened arguments
+  if (encodings && !Array.isArray(encodings)) {
+    encodings = new Array(arguments.length)
+    for (var i = 0; i < encodings.length; i++) {
+      encodings[i] = arguments[i]
+    }
+  }
+
+  // no encodings, return all requested encodings
+  if (!encodings || encodings.length === 0) {
+    return this.negotiator.encodings()
+  }
+
+  return this.negotiator.encodings(encodings)[0] || false
+}
+
+/**
+ * Return accepted charsets or best fit based on `charsets`.
+ *
+ * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+ * an array sorted by quality is returned:
+ *
+ *     ['utf-8', 'utf-7', 'iso-8859-1']
+ *
+ * @param {String|Array} charsets...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.charset =
+Accepts.prototype.charsets = function (charsets_) {
+  var charsets = charsets_
+
+  // support flattened arguments
+  if (charsets && !Array.isArray(charsets)) {
+    charsets = new Array(arguments.length)
+    for (var i = 0; i < charsets.length; i++) {
+      charsets[i] = arguments[i]
+    }
+  }
+
+  // no charsets, return all requested charsets
+  if (!charsets || charsets.length === 0) {
+    return this.negotiator.charsets()
+  }
+
+  return this.negotiator.charsets(charsets)[0] || false
+}
+
+/**
+ * Return accepted languages or best fit based on `langs`.
+ *
+ * Given `Accept-Language: en;q=0.8, es, pt`
+ * an array sorted by quality is returned:
+ *
+ *     ['es', 'pt', 'en']
+ *
+ * @param {String|Array} langs...
+ * @return {Array|String}
+ * @public
+ */
+
+Accepts.prototype.lang =
+Accepts.prototype.langs =
+Accepts.prototype.language =
+Accepts.prototype.languages = function (languages_) {
+  var languages = languages_
+
+  // support flattened arguments
+  if (languages && !Array.isArray(languages)) {
+    languages = new Array(arguments.length)
+    for (var i = 0; i < languages.length; i++) {
+      languages[i] = arguments[i]
+    }
+  }
+
+  // no languages, return all requested languages
+  if (!languages || languages.length === 0) {
+    return this.negotiator.languages()
+  }
+
+  return this.negotiator.languages(languages)[0] || false
+}
+
+/**
+ * Convert extnames to mime.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function extToMime (type) {
+  return type.indexOf('/') === -1
+    ? mime.lookup(type)
+    : type
+}
+
+/**
+ * Check if mime is valid.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function validMime (type) {
+  return typeof type === 'string'
+}

bigdata/node_modules/_accepts@1.3.7@accepts/node_modules/mime-types

+../../_mime-types@2.1.25@mime-types
\ No newline at end of file