dexbot 1.4.16 → 1.4.17

package/claw/node_modules/assert/test.js

@@ -1,360 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-var nodeAssert = require('assert');
-var ourAssert = require('./');
-var keys = Object.keys;
-if (process.env.TEST_NATIVE === true) {
-  tests(nodeAssert, 'node assert');
-} else {
-  tests(ourAssert, 'our assert');
-}
-
-function makeBlock(f) {
-  var args = Array.prototype.slice.call(arguments, 1);
-  return function() {
-    return f.apply(this, args);
-  };
-}
-
-function tests (assert, what) {
-    test('assert.ok', function () {
-      assert.throws(makeBlock(assert, false), assert.AssertionError, 'ok(false)');
-
-      assert.doesNotThrow(makeBlock(assert, true), assert.AssertionError, 'ok(true)');
-
-      assert.doesNotThrow(makeBlock(assert, 'test', 'ok(\'test\')'));
-
-      assert.throws(makeBlock(assert.ok, false),
-                    assert.AssertionError, 'ok(false)');
-
-      assert.doesNotThrow(makeBlock(assert.ok, true),
-                          assert.AssertionError, 'ok(true)');
-
-      assert.doesNotThrow(makeBlock(assert.ok, 'test'), 'ok(\'test\')');
-    });
-
-    test('assert.equal', function () {
-      assert.throws(makeBlock(assert.equal, true, false), assert.AssertionError, 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, null, null), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, undefined, undefined), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, null, undefined), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, true, true), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, 2, '2'), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.notEqual, true, false), 'notEqual');
-
-      assert.throws(makeBlock(assert.notEqual, true, true),
-                    assert.AssertionError, 'notEqual');
-    });
-
-    test('assert.strictEqual', function () {
-      assert.throws(makeBlock(assert.strictEqual, 2, '2'),
-                    assert.AssertionError, 'strictEqual');
-
-      assert.throws(makeBlock(assert.strictEqual, null, undefined),
-                    assert.AssertionError, 'strictEqual');
-
-      assert.doesNotThrow(makeBlock(assert.notStrictEqual, 2, '2'), 'notStrictEqual');
-    });
-
-    test('assert.deepStrictEqual', function () {
-      assert.throws(makeBlock(assert.deepStrictEqual, [2], ['2']),
-                    assert.AssertionError, 'deepStrictEqual');
-
-      assert.throws(makeBlock(assert.deepStrictEqual, [null], [undefined]),
-                    assert.AssertionError, 'deepStrictEqual');
-
-      assert.doesNotThrow(makeBlock(assert.notDeepStrictEqual, [2], ['2']), 'notDeepStrictEqual');
-    });
-
-    test('assert.deepEqual - 7.2', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Date(2000, 3, 14),
-                          new Date(2000, 3, 14)), 'deepEqual date');
-
-      assert.throws(makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)),
-                    assert.AssertionError,
-                    'deepEqual date');
-    });
-
-    test('assert.deepEqual - 7.3', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/, /a/));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/g, /a/g));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/i, /a/i));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/m, /a/m));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/igm, /a/igm));
-      assert.throws(makeBlock(assert.deepEqual, /ab/, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/g, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/i, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/m, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/igm, /a/im));
-
-      var re1 = /a/;
-      re1.lastIndex = 3;
-      assert.throws(makeBlock(assert.deepEqual, re1, /a/));
-    });
-
-    test('assert.deepEqual - 7.4', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, 4, '4'), 'deepEqual == check');
-      assert.doesNotThrow(makeBlock(assert.deepEqual, true, 1), 'deepEqual == check');
-      assert.throws(makeBlock(assert.deepEqual, 4, '5'),
-                assert.AssertionError,
-                'deepEqual == check');
-    });
-
-    test('assert.deepEqual - 7.5', function () {
-      // having the same number of owned properties && the same set of keys
-      assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4}, {a: 4}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, [4], ['4']));
-      assert.throws(makeBlock(assert.deepEqual, {a: 4}, {a: 4, b: true}),
-                assert.AssertionError);
-      assert.doesNotThrow(makeBlock(assert.deepEqual, ['a'], {0: 'a'}));
-      //(although not necessarily the same order),
-      assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '1'}, {b: '1', a: 4}));
-      var a1 = [1, 2, 3];
-      var a2 = [1, 2, 3];
-      a1.a = 'test';
-      a1.b = true;
-      a2.b = true;
-      a2.a = 'test';
-      assert.throws(makeBlock(assert.deepEqual, keys(a1), keys(a2)),
-                assert.AssertionError);
-      assert.doesNotThrow(makeBlock(assert.deepEqual, a1, a2));
-    });
-
-    test('assert.deepEqual - ES6 primitives', function () {
-      assert.throws(makeBlock(assert.deepEqual, null, {}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, undefined, {}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, 'a', ['a']), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, 'a', {0: 'a'}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, 1, {}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, true, {}), assert.AssertionError);
-      if (typeof Symbol === 'symbol') {
-        assert.throws(makeBlock(assert.deepEqual, Symbol(), {}), assert.AssertionError);
-      }
-    });
-
-    test('assert.deepEqual - object wrappers', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), ['a']));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), {0: 'a'}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Number(1), {}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Boolean(true), {}));
-    });
-
-    test('assert.deepEqual - Buffers', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Buffer([1, 2, 3]), new Buffer([1, 2, 3])));
-      if (typeof global.Uint8Array === 'function') {
-        assert.throws(makeBlock(assert.deepEqual, new Buffer([1, 2, 3]), new Uint8Array([1, 2, 3])));
-      }
-      if (typeof global.Uint16Array === 'function') {
-        assert.doesNotThrow(makeBlock(assert.deepEqual, new Uint16Array([1, 2, 3]), new Uint16Array([1, 2, 3])));
-      }
-    });
-
-    function thrower(errorConstructor) {
-      throw new errorConstructor('test');
-    }
-
-    test('assert - testing the throwing', function () {
-      var aethrow = makeBlock(thrower, assert.AssertionError);
-      aethrow = makeBlock(thrower, assert.AssertionError);
-
-      // the basic calls work
-      assert.throws(makeBlock(thrower, assert.AssertionError),
-                    assert.AssertionError, 'message');
-      assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError);
-      assert.throws(makeBlock(thrower, assert.AssertionError));
-
-      // if not passing an error, catch all.
-      assert.throws(makeBlock(thrower, TypeError));
-
-      // when passing a type, only catch errors of the appropriate type
-      var threw = false;
-      try {
-        assert.throws(makeBlock(thrower, TypeError), assert.AssertionError);
-      } catch (e) {
-        threw = true;
-        assert.ok(e instanceof TypeError, 'type');
-      }
-      assert.equal(true, threw,
-                   'a.throws with an explicit error is eating extra errors',
-                   assert.AssertionError);
-      threw = false;
-
-      // doesNotThrow should pass through all errors
-      try {
-        assert.doesNotThrow(makeBlock(thrower, TypeError), assert.AssertionError);
-      } catch (e) {
-        threw = true;
-        assert.ok(e instanceof TypeError);
-      }
-      assert.equal(true, threw,
-                   'a.doesNotThrow with an explicit error is eating extra errors');
-
-      // key difference is that throwing our correct error makes an assertion error
-      try {
-        assert.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
-      } catch (e) {
-        threw = true;
-        assert.ok(e instanceof assert.AssertionError);
-      }
-      assert.equal(true, threw,
-                   'a.doesNotThrow is not catching type matching errors');
-    });
-
-    test('assert.ifError', function () {
-      assert.throws(function() {assert.ifError(new Error('test error'))});
-      assert.doesNotThrow(function() {assert.ifError(null)});
-      assert.doesNotThrow(function() {assert.ifError()});
-    });
-
-    test('assert - make sure that validating using constructor really works', function () {
-      var threw = false;
-      try {
-        assert.throws(
-            function() {
-              throw ({});
-            },
-            Array
-        );
-      } catch (e) {
-        threw = true;
-      }
-      assert.ok(threw, 'wrong constructor validation');
-    });
-
-    test('assert - use a RegExp to validate error message', function () {
-      assert.throws(makeBlock(thrower, TypeError), /test/);
-    });
-
-    test('assert - use a fn to validate error object', function () {
-      assert.throws(makeBlock(thrower, TypeError), function(err) {
-        if ((err instanceof TypeError) && /test/.test(err)) {
-          return true;
-        }
-      });
-    });
-
-    test('assert - make sure deepEqual doesn\'t loop forever on circular refs', function () {
-      var b = {};
-      b.b = b;
-
-      var c = {};
-      c.b = c;
-
-      var gotError = false;
-      var equal = true;
-      try {
-        equal = assert.deepEqual(b, c);
-      } catch (e) {
-        gotError = true;
-      }
-      assert.ok(gotError || !equal, gotError ? 'got error': 'are equal');
-    });
-
-    test('assert - ensure reflexivity of deepEqual with `arguments` objects', function() {
-        var args = (function() { return arguments; })();
-        assert.throws(makeBlock(assert.deepEqual, [], args), assert.AssertionError);
-        assert.throws(makeBlock(assert.deepEqual, args, []), assert.AssertionError);
-    });
-
-    test('assert - test assertion message', function () {
-      function testAssertionMessage(actual, expected) {
-        try {
-          assert.equal(actual, '');
-        } catch (e) {
-          assert.equal(e.toString(),
-              ['AssertionError:', expected, '==', '\'\''].join(' '));
-        }
-      }
-      testAssertionMessage(undefined, 'undefined');
-      testAssertionMessage(null, 'null');
-      testAssertionMessage(true, 'true');
-      testAssertionMessage(false, 'false');
-      testAssertionMessage(0, '0');
-      testAssertionMessage(100, '100');
-      testAssertionMessage(NaN, 'NaN');
-      testAssertionMessage(Infinity, 'Infinity');
-      testAssertionMessage(-Infinity, '-Infinity');
-      testAssertionMessage('', '""');
-      testAssertionMessage('foo', '\'foo\'');
-      testAssertionMessage([], '[]');
-      testAssertionMessage([1, 2, 3], '[ 1, 2, 3 ]');
-      testAssertionMessage(new Buffer([1, 2, 3]), '<Buffer 01 02 03>');
-      if (typeof global.Uint8Array === 'function' && Object.getOwnPropertyNames( new Uint8Array([])).length === 0) {
-        // todo fix util.inspect
-        testAssertionMessage(new Uint8Array([1, 2, 3]), '{ \'0\': 1, \'1\': 2, \'2\': 3 }');
-      }
-      testAssertionMessage(/a/, '/a/');
-      testAssertionMessage(function f() {}, '[Function: f]');
-      testAssertionMessage({}, '{}');
-      testAssertionMessage({a: undefined, b: null}, '{ a: undefined, b: null }');
-      testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
-          '{ a: NaN, b: Infinity, c: -Infinity }');
-    });
-
-    test('assert - regressions from node.js testcase', function () {
-      var threw = false;
-
-      try {
-        assert.throws(function () {
-          assert.ifError(null);
-        });
-      } catch (e) {
-        threw = true;
-        assert.equal(e.message, 'Missing expected exception..');
-      }
-      assert.ok(threw);
-
-      try {
-        assert.equal(1, 2);
-      } catch (e) {
-        assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2');
-      }
-
-      try {
-        assert.equal(1, 2, 'oh no');
-      } catch (e) {
-        assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no');
-      }
-    });
-
-    test('assert - strict mode', function () {
-      var assertStrict = assert.strict;
-
-      assertStrict.throws(makeBlock(assertStrict.equal, 1, true), assertStrict.AssertionError);
-      assertStrict.notEqual(0, false);
-      assertStrict.throws(makeBlock(assertStrict.deepEqual, 1, true), assertStrict.AssertionError);
-      assertStrict.notDeepEqual(0, false);
-      assertStrict.equal(assertStrict.strict, assertStrict.strict.strict);
-      assertStrict.equal(assertStrict.equal, assertStrict.strictEqual);
-      assertStrict.equal(assertStrict.deepEqual, assertStrict.deepStrictEqual);
-      assertStrict.equal(assertStrict.notEqual, assertStrict.notStrictEqual);
-      assertStrict.equal(assertStrict.notDeepEqual, assertStrict.notDeepStrictEqual);
-      assertStrict.equal(Object.keys(assertStrict).length, Object.keys(assert).length);
-    });
-}

package/claw/node_modules/async-limiter/.eslintignore

@@ -1,2 +0,0 @@
-coverage
-.nyc_output

package/claw/node_modules/async-limiter/.nycrc

@@ -1,10 +0,0 @@
-{
-  "check-coverage": false,
-  "lines": 99,
-  "statements": 99,
-  "functions": 99,
-  "branches": 99,
-  "include": [
-     "index.js"
-  ]
-}

package/claw/node_modules/async-limiter/.travis.yml

@@ -1,9 +0,0 @@
-language: node_js
-node_js:
-  - "6"
-  - "8"
-  - "10"
-  - "node"
-script: npm run travis
-cache:
-  yarn: true

package/claw/node_modules/async-limiter/LICENSE

@@ -1,8 +0,0 @@
-The MIT License (MIT)
-Copyright (c) 2017 Samuel Reed <samuel.trace.reed@gmail.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.

package/claw/node_modules/async-limiter/index.js

@@ -1,67 +0,0 @@
-'use strict';
-
-function Queue(options) {
-  if (!(this instanceof Queue)) {
-    return new Queue(options);
-  }
-
-  options = options || {};
-  this.concurrency = options.concurrency || Infinity;
-  this.pending = 0;
-  this.jobs = [];
-  this.cbs = [];
-  this._done = done.bind(this);
-}
-
-var arrayAddMethods = [
-  'push',
-  'unshift',
-  'splice'
-];
-
-arrayAddMethods.forEach(function(method) {
-  Queue.prototype[method] = function() {
-    var methodResult = Array.prototype[method].apply(this.jobs, arguments);
-    this._run();
-    return methodResult;
-  };
-});
-
-Object.defineProperty(Queue.prototype, 'length', {
-  get: function() {
-    return this.pending + this.jobs.length;
-  }
-});
-
-Queue.prototype._run = function() {
-  if (this.pending === this.concurrency) {
-    return;
-  }
-  if (this.jobs.length) {
-    var job = this.jobs.shift();
-    this.pending++;
-    job(this._done);
-    this._run();
-  }
-
-  if (this.pending === 0) {
-    while (this.cbs.length !== 0) {
-      var cb = this.cbs.pop();
-      process.nextTick(cb);
-    }
-  }
-};
-
-Queue.prototype.onDone = function(cb) {
-  if (typeof cb === 'function') {
-    this.cbs.push(cb);
-    this._run();
-  }
-};
-
-function done() {
-  this.pending--;
-  this._run();
-}
-
-module.exports = Queue;

package/claw/node_modules/async-limiter/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "async-limiter",
-  "version": "1.0.1",
-  "description": "asynchronous function queue with adjustable concurrency",
-  "keywords": [
-    "throttle",
-    "async",
-    "limiter",
-    "asynchronous",
-    "job",
-    "task",
-    "concurrency",
-    "concurrent"
-  ],
-  "dependencies": {},
-  "devDependencies": {
-    "coveralls": "^3.0.3",
-    "eslint": "^5.16.0",
-    "eslint-plugin-mocha": "^5.3.0",
-    "intelli-espower-loader": "^1.0.1",
-    "mocha": "^6.1.4",
-    "nyc": "^14.1.1",
-    "power-assert": "^1.6.1"
-  },
-  "scripts": {
-    "test": "mocha --require intelli-espower-loader test/",
-    "travis": "npm run lint && npm run test",
-    "coverage": "nyc npm test && nyc report --reporter=text-lcov | coveralls",
-    "example": "node example",
-    "lint": "eslint ."
-  },
-  "repository": "https://github.com/strml/async-limiter.git",
-  "author": "Samuel Reed <samuel.trace.reed@gmail.com",
-  "license": "MIT"
-}

package/claw/node_modules/async-limiter/readme.md

@@ -1,132 +0,0 @@
-# Async-Limiter
-
-A module for limiting concurrent asynchronous actions in flight. Forked from [queue](https://github.com/jessetane/queue).
-
-[![npm](http://img.shields.io/npm/v/async-limiter.svg?style=flat-square)](http://www.npmjs.org/async-limiter)
-[![tests](https://img.shields.io/travis/STRML/async-limiter.svg?style=flat-square&branch=master)](https://travis-ci.org/STRML/async-limiter)
-[![coverage](https://img.shields.io/coveralls/STRML/async-limiter.svg?style=flat-square&branch=master)](https://coveralls.io/r/STRML/async-limiter)
-
-This module exports a class `Limiter` that implements some of the `Array` API.
-Pass async functions (ones that accept a callback or return a promise) to an instance's additive array methods.
-
-## Motivation
-
-Certain functions, like `zlib`, have [undesirable behavior](https://github.com/nodejs/node/issues/8871#issuecomment-250915913) when
-run at infinite concurrency.
-
-In this case, it is actually faster, and takes far less memory, to limit concurrency.
-
-This module should do the absolute minimum work necessary to queue up functions. PRs are welcome that would
-make this module faster or lighter, but new functionality is not desired.
-
-Style should confirm to nodejs/node style.
-
-## Example
-
-``` javascript
-var Limiter = require('async-limiter')
-
-var t = new Limiter({concurrency: 2});
-var results = []
-
-// add jobs using the familiar Array API
-t.push(function (cb) {
-  results.push('two')
-  cb()
-})
-
-t.push(
-  function (cb) {
-    results.push('four')
-    cb()
-  },
-  function (cb) {
-    results.push('five')
-    cb()
-  }
-)
-
-t.unshift(function (cb) {
-  results.push('one')
-  cb()
-})
-
-t.splice(2, 0, function (cb) {
-  results.push('three')
-  cb()
-})
-
-// Jobs run automatically. If you want a callback when all are done,
-// call 'onDone()'.
-t.onDone(function () {
-  console.log('all done:', results)
-})
-```
-
-## Zlib Example
-
-```js
-const zlib = require('zlib');
-const Limiter = require('async-limiter');
-
-const message = {some: "data"};
-const payload = new Buffer(JSON.stringify(message));
-
-// Try with different concurrency values to see how this actually
-// slows significantly with higher concurrency!
-//
-// 5:        1398.607ms
-// 10:       1375.668ms
-// Infinity: 4423.300ms
-//
-const t = new Limiter({concurrency: 5});
-function deflate(payload, cb) {
-  t.push(function(done) {
-    zlib.deflate(payload, function(err, buffer) {
-      done();
-      cb(err, buffer);
-    });
-  });
-}
-
-console.time('deflate');
-for(let i = 0; i < 30000; ++i) {
-  deflate(payload, function (err, buffer) {});
-}
-t.onDone(function() {
-  console.timeEnd('deflate');
-});
-```
-
-## Install
-
-`npm install async-limiter`
-
-## Test
-
-`npm test`
-
-## API
-
-### `var t = new Limiter([opts])`
-Constructor. `opts` may contain inital values for:
-* `t.concurrency`
-
-## Instance methods
-
-### `t.onDone(fn)`
-`fn` will be called once and only once, when the queue is empty.
-
-## Instance methods mixed in from `Array`
-Mozilla has docs on how these methods work [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
-### `t.push(element1, ..., elementN)`
-### `t.unshift(element1, ..., elementN)`
-### `t.splice(index , howMany[, element1[, ...[, elementN]]])`
-
-## Properties
-### `t.concurrency`
-Max number of jobs the queue should process concurrently, defaults to `Infinity`.
-
-### `t.length`
-Jobs pending + jobs to process (readonly).
-

package/claw/node_modules/available-typed-arrays/.eslintrc

@@ -1,5 +0,0 @@
-{
-	"root": true,
-
-	"extends": "@ljharb",
-}

package/claw/node_modules/available-typed-arrays/.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: [ljharb]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: npm/available-typed-arrays
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/claw/node_modules/available-typed-arrays/.nycrc

@@ -1,9 +0,0 @@
-{
-	"all": true,
-	"check-coverage": false,
-	"reporter": ["text-summary", "text", "html", "json"],
-	"exclude": [
-		"coverage",
-		"test"
-	]
-}