@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/node-gyp/gyp/pylib/gyp/generator/cmake_test.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-
-"""Unit tests for the cmake.py file."""
-
-import io
-import types
-import unittest
-
-from gyp.generator import cmake
-
-
-class TestCustomCommandComment(unittest.TestCase):
-    def test_ActionMessageIsQuotedAndEscaped(self):
-        output = io.StringIO()
-        action = {
-            "action_name": "gen",
-            "inputs": ["in.txt"],
-            "outputs": ["out.txt"],
-            "action": ["python", "gen.py"],
-            "message": 'Generating "out.txt"; (see #1)',
-        }
-        cmake.WriteActions("tgt", [action], [], [], ".", output)
-        self.assertIn(
-            '  COMMENT "Generating \\"out.txt\\"\\; (see #1)"\n', output.getvalue()
-        )
-
-    def test_ActionWithoutMessageUsesTargetName(self):
-        output = io.StringIO()
-        action = {
-            "action_name": "gen",
-            "inputs": [],
-            "outputs": ["out.txt"],
-            "action": ["python", "gen.py"],
-        }
-        cmake.WriteActions("tgt", [action], [], [], ".", output)
-        self.assertIn('  COMMENT "tgt__gen"\n', output.getvalue())
-
-    def test_RuleMessageKeepsVariableReferences(self):
-        output = io.StringIO()
-        rule = {
-            "rule_name": "compile",
-            "outputs": ["${RULE_INPUT_ROOT}.o"],
-            "action": ["cc", "${RULE_INPUT_PATH}"],
-            "rule_sources": ["foo.c"],
-            "message": "Compiling ${RULE_INPUT_NAME}",
-        }
-        cmake.WriteRules("tgt", [rule], [], [], ".", output)
-        self.assertIn('  COMMENT "Compiling ${RULE_INPUT_NAME}"\n', output.getvalue())
-
-    def test_CopiesMessageIsQuoted(self):
-        output = io.StringIO()
-        copies = [{"files": ["a.txt"], "destination": "out"}]
-        cmake.WriteCopies("tgt", copies, [], ".", output)
-        self.assertIn('COMMENT "Copying for tgt"\n', output.getvalue())
-
-
-class TestTargetWithoutSources(unittest.TestCase):
-    def _WriteTarget(self, target_type, sources=()):
-        qualified_target = "foo.gyp:foo#target"
-        spec = {
-            "target_name": "foo",
-            "type": target_type,
-            "toolset": "target",
-            "sources": list(sources),
-        }
-        output = io.StringIO()
-        cmake.WriteTarget(
-            cmake.CMakeNamer([qualified_target]),
-            qualified_target,
-            {qualified_target: spec},
-            "out/Default",
-            "Default",
-            types.SimpleNamespace(toplevel_dir="."),
-            {},
-            [qualified_target],
-            "linux",
-            output,
-        )
-        return output.getvalue()
-
-    def test_DummySourceForEmptyTargets(self):
-        for target_type, add_target in (
-            ("executable", "add_executable(foo"),
-            ("static_library", "add_library(foo STATIC"),
-            ("shared_library", "add_library(foo SHARED"),
-            ("loadable_module", "add_library(foo MODULE"),
-        ):
-            with self.subTest(target_type=target_type):
-                output = self._WriteTarget(target_type)
-                self.assertIn('  file(WRITE "${foo__dummy_srcs}" "")\n', output)
-                self.assertIn(add_target + " ${foo__dummy_srcs})\n", output)
-
-    def test_NoDummySourceForLibraryWithSources(self):
-        output = self._WriteTarget("static_library", ["foo.c"])
-        self.assertIn("add_library(foo STATIC ${foo__c_srcs})\n", output)
-        self.assertNotIn("dummy", output)
-
-    def test_NoDummySourceForNoneTarget(self):
-        output = self._WriteTarget("none")
-        self.assertIn("add_custom_target(foo SOURCES)\n", output)
-        self.assertNotIn("dummy", output)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/node_modules/node-gyp/zizmor.yml

@@ -1,5 +0,0 @@
-rules:
-  adhoc-packages:
-    disable: true
-  excessive-permissions:
-    disable: true

package/node_modules/proxy-agent-negotiate/dist/index.d.ts

@@ -1,14 +0,0 @@
-import type { OutgoingHttpHeaders, IncomingHttpHeaders } from 'http';
-export interface ProxyAuthResponse {
-    headers: OutgoingHttpHeaders;
-}
-export interface ProxyAuthParams {
-    response: {
-        statusCode: number;
-        headers: IncomingHttpHeaders;
-    };
-    scheme: string;
-}
-export type OnProxyAuthCallback = (params: ProxyAuthParams) => Promise<ProxyAuthResponse>;
-export declare function createNegotiateAuth(): OnProxyAuthCallback;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/proxy-agent-negotiate/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAErE,MAAM,WAAW,iBAAiB;IACjC,OAAO,EAAE,mBAAmB,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,EAAE;QACT,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,mBAAmB,CAAC;KAC7B,CAAC;IACF,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,mBAAmB,GAAG,CACjC,MAAM,EAAE,eAAe,KACnB,OAAO,CAAC,iBAAiB,CAAC,CAAC;AAEhC,wBAAgB,mBAAmB,IAAI,mBAAmB,CAwCzD"}

package/node_modules/proxy-agent-negotiate/dist/index.js

@@ -1,35 +0,0 @@
-export function createNegotiateAuth() {
-    return async ({ response, scheme }) => {
-        if (scheme.toLowerCase() !== 'negotiate') {
-            throw new Error(`Expected Negotiate scheme but got "${scheme}"`);
-        }
-        let kerberos;
-        try {
-            kerberos = await import('kerberos');
-        }
-        catch {
-            throw new Error('The "kerberos" package is required for Negotiate proxy authentication. ' +
-                'Install it with: npm install kerberos');
-        }
-        const proxyAuthenticate = response.headers['proxy-authenticate'] || '';
-        const challengeHeader = Array.isArray(proxyAuthenticate)
-            ? proxyAuthenticate[0]
-            : proxyAuthenticate;
-        const serverToken = typeof challengeHeader === 'string' && challengeHeader.includes(' ')
-            ? challengeHeader.split(' ').slice(1).join(' ')
-            : undefined;
-        const client = await kerberos.initializeClient('HTTP@proxy', {
-            mechOID: kerberos.GSS_MECH_OID_SPNEGO,
-        });
-        const token = await client.step(serverToken || '');
-        if (!token) {
-            throw new Error('Kerberos client.step() returned no token');
-        }
-        return {
-            headers: {
-                'Proxy-Authorization': `Negotiate ${token}`,
-            },
-        };
-    };
-}
-//# sourceMappingURL=index.js.map

package/node_modules/proxy-agent-negotiate/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAkBA,MAAM,UAAU,mBAAmB;IAClC,OAAO,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE;QACrC,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,WAAW,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,sCAAsC,MAAM,GAAG,CAAC,CAAC;QAClE,CAAC;QAED,IAAI,QAAQ,CAAC;QACb,IAAI,CAAC;YACJ,QAAQ,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;QAAC,MAAM,CAAC;YACR,MAAM,IAAI,KAAK,CACd,yEAAyE;gBACxE,uCAAuC,CACxC,CAAC;QACH,CAAC;QAED,MAAM,iBAAiB,GAAG,QAAQ,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC;QACvE,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC;YACvD,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;YACtB,CAAC,CAAC,iBAAiB,CAAC;QACrB,MAAM,WAAW,GAChB,OAAO,eAAe,KAAK,QAAQ,IAAI,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC;YACnE,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;YAC/C,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,gBAAgB,CAAC,YAAY,EAAE;YAC5D,OAAO,EAAE,QAAQ,CAAC,mBAAmB;SACrC,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC7D,CAAC;QAED,OAAO;YACN,OAAO,EAAE;gBACR,qBAAqB,EAAE,aAAa,KAAK,EAAE;aAC3C;SACD,CAAC;IACH,CAAC,CAAC;AACH,CAAC"}

package/node_modules/proxy-agent-negotiate/package.json

@@ -1,47 +0,0 @@
-{
-  "name": "proxy-agent-negotiate",
-  "version": "1.1.0",
-  "type": "module",
-  "description": "Negotiate/SPNEGO proxy authentication for proxy-agents",
-  "exports": {
-    "types": "./dist/index.d.ts",
-    "default": "./dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/TooTallNate/proxy-agents.git",
-    "directory": "packages/negotiate"
-  },
-  "keywords": [
-    "proxy",
-    "negotiate",
-    "kerberos",
-    "spnego",
-    "authentication"
-  ],
-  "author": "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^22.13.0",
-    "typescript": "^5.1.6",
-    "tsconfig": "0.0.0"
-  },
-  "engines": {
-    "node": ">= 20"
-  },
-  "peerDependencies": {
-    "kerberos": "^2.0.0"
-  },
-  "peerDependenciesMeta": {
-    "kerberos": {
-      "optional": true
-    }
-  },
-  "scripts": {
-    "build": "tsc",
-    "pack": "node ../../scripts/pack.mjs"
-  }
-}

package/node_modules/undici/docs/docs/api/CacheStore.md

@@ -1,360 +0,0 @@
-# Cache Store
-
-<!--introduced_in=v7.0.0-->
-<!--type=module-->
-<!-- source_link=lib/cache/memory-cache-store.js -->
-
-> Stability: 2 - Stable
-
-A cache store is the storage backend used by the cache interceptor to persist
-and retrieve cached responses. A store decides which stored response to serve
-for a request by comparing the request against the response's `Vary` header, and
-is expected to be compliant with [RFC&nbsp;9111][].
-
-undici ships two stores. `MemoryCacheStore` keeps responses in memory, while
-`SqliteCacheStore` persists them to a SQLite database. Both are available under
-the `cacheStores` export:
-
-```mjs
-import { cacheStores } from 'undici'
-
-const { MemoryCacheStore, SqliteCacheStore } = cacheStores
-```
-
-`SqliteCacheStore` requires the [`node:sqlite`][] API. The class is always
-exported, but constructing one throws if `node:sqlite` is not available in the
-running Node.js version.
-
-A cache store implements three methods — `get(key)`, `createWriteStream(key,
-value)`, and `delete(key)` — that operate on a [`CacheKey`](#cachekey) and a
-[`CacheValue`](#cachevalue). Any object implementing this contract can be passed
-to the cache interceptor, so custom stores (for example, backed by Redis or a
-remote service) are supported as well.
-
-## Class: `MemoryCacheStore`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* Extends: {EventEmitter}
-
-Stores cached responses in memory. The store enforces upper bounds on the total
-number of responses, the total size of all responses, and the size of any single
-response. When a limit is exceeded, the store evicts approximately half of its
-entries and emits a [`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
-
-```mjs
-import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
-
-const store = new cacheStores.MemoryCacheStore({ maxSize: 50 * 1024 * 1024 })
-
-setGlobalDispatcher(
-  new Agent().compose(interceptors.cache({ store }))
-)
-```
-
-### `new MemoryCacheStore([options])`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `options` {Object} (optional)
-  * `maxCount` {number} The maximum number of responses to store. **Default:**
-    `1024`.
-  * `maxSize` {number} The maximum total size, in bytes, of all stored
-    responses. **Default:** `104857600` (100 MiB).
-  * `maxEntrySize` {number} The maximum size, in bytes, of a single response
-    body. Responses whose body exceeds this value are not cached. **Default:**
-    `5242880` (5 MiB).
-  * `errorCallback` {Function} A callback invoked with any error raised by the
-    store. (optional)
-    * `err` {Error}
-
-Each of `maxCount`, `maxSize`, and `maxEntrySize` must be a non-negative
-integer; a `TypeError` is thrown otherwise.
-
-### `memoryCacheStore.size`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* Type: {number}
-
-The current total size, in bytes, of all stored response bodies.
-
-### `memoryCacheStore.isFull()`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* Returns: {boolean} `true` when the store has reached its `maxSize` or
-  `maxCount` limit, `false` otherwise.
-
-### `memoryCacheStore.get(key)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request to look up. See [`CacheKey`](#cachekey).
-* Returns: {GetResult|undefined} The matching cached response, or `undefined`
-  when there is no fresh entry for `key`. See [`GetResult`](#getresult).
-
-Looks up a cached response for `key`. A stored entry matches only when its
-`method` equals `key.method`, its `deleteAt` time is in the future, and every
-header listed in its `vary` map matches the corresponding header in
-`key.headers`.
-
-### `memoryCacheStore.createWriteStream(key, value)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request the response is being cached for. See
-  [`CacheKey`](#cachekey).
-* `value` {CacheValue} The response metadata to store. See
-  [`CacheValue`](#cachevalue).
-* Returns: {Writable|undefined} A writable stream that the response body is
-  written to, or `undefined` when the response cannot be cached.
-
-Returns a {Writable} stream used to write the response body into the store. When
-the stream finishes, the entry is committed; if its accumulated size exceeds
-`maxEntrySize`, the stream is destroyed and nothing is stored. Writing a new
-entry whose `key` matches an existing one replaces that entry.
-
-### `memoryCacheStore.delete(key)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request whose cached responses should be removed. See
-  [`CacheKey`](#cachekey).
-* Returns: {undefined}
-
-Removes every cached response stored for `key.origin` and `key.path`. Throws a
-`TypeError` if `key` is not an object.
-
-### Event: `'maxSizeExceeded'`
-
-<!-- YAML
-added: v7.10.0
--->
-
-* `data` {Object}
-  * `size` {number} The current total size, in bytes, of all stored responses.
-  * `maxSize` {number} The configured `maxSize` limit.
-  * `count` {number} The current number of stored responses.
-  * `maxCount` {number} The configured `maxCount` limit.
-
-Emitted when the store exceeds its `maxSize` or `maxCount` limit, immediately
-before entries are evicted. The event fires only once per overflow; it is not
-emitted again until the store drops back below both limits.
-
-## Class: `SqliteCacheStore`
-
-<!-- YAML
-added: v7.0.0
--->
-
-Stores cached responses in a SQLite database using the [`node:sqlite`][] API.
-The constructor throws when [`node:sqlite`][] is not available.
-
-```mjs
-import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
-
-const store = new cacheStores.SqliteCacheStore({ location: './cache.db' })
-
-setGlobalDispatcher(
-  new Agent().compose(interceptors.cache({ store }))
-)
-```
-
-### `new SqliteCacheStore([options])`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `options` {Object} (optional)
-  * `location` {string} The location of the SQLite database. Use `':memory:'`
-    for an in-memory database. **Default:** `':memory:'`.
-  * `maxCount` {number} The maximum number of responses to store. **Default:**
-    `Infinity`.
-  * `maxEntrySize` {number} The maximum size, in bytes, of a single response
-    body. Responses whose body exceeds this value are not cached. Must not
-    exceed `2000000000` (2 GB). **Default:** `2000000000` (2 GB).
-
-`maxCount` and `maxEntrySize` must be non-negative integers; a `TypeError` is
-thrown otherwise, or if `maxEntrySize` is greater than 2 GB.
-
-### `sqliteCacheStore.close()`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* Returns: {undefined}
-
-Closes the connection to the underlying SQLite database.
-
-### `sqliteCacheStore.size`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* Type: {number}
-
-The number of responses currently stored in the database.
-
-### `sqliteCacheStore.get(key)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request to look up. See [`CacheKey`](#cachekey).
-* Returns: {GetResult|undefined} The matching cached response, or `undefined`
-  when there is no fresh entry for `key`. The returned `body` is a {Buffer}.
-  See [`GetResult`](#getresult).
-
-Looks up a cached response for `key`, comparing the request method and every
-header named in the stored `vary` map.
-
-### `sqliteCacheStore.set(key, value)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request the response is being cached for. See
-  [`CacheKey`](#cachekey).
-* `value` {CacheValue} The response to store, with its `body` set to a {Buffer},
-  an {Array} of {Buffer}, or `null`. See [`CacheValue`](#cachevalue).
-* Returns: {undefined}
-
-Writes a response into the database directly, without going through a stream. If
-the body exceeds `maxEntrySize`, nothing is stored. When an entry already exists
-for `key` it is overwritten; otherwise a new row is inserted and old entries are
-pruned to honour `maxCount`. This method is used internally by
-[`sqliteCacheStore.createWriteStream()`](#sqlitecachestorecreatewritestreamkey-value).
-
-### `sqliteCacheStore.createWriteStream(key, value)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request the response is being cached for. See
-  [`CacheKey`](#cachekey).
-* `value` {CacheValue} The response metadata to store. See
-  [`CacheValue`](#cachevalue).
-* Returns: {Writable|undefined} A writable stream that the response body is
-  written to, or `undefined` when the response cannot be cached.
-
-Returns a {Writable} stream used to write the response body into the store. When
-the stream finishes, the buffered body is committed via
-[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value). If the body exceeds
-`maxEntrySize`, the stream is destroyed and nothing is stored.
-
-### `sqliteCacheStore.delete(key)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `key` {CacheKey} The request whose cached responses should be removed. See
-  [`CacheKey`](#cachekey).
-* Returns: {undefined}
-
-Removes every cached response stored for the URL derived from `key.origin` and
-`key.path`. Throws a `TypeError` if `key` is not an object.
-
-## Implementing a custom cache store
-
-A cache store is any object that implements the `CacheStore` interface:
-
-* `get(key)` — Look up a response. Returns a [`GetResult`](#getresult),
-  `undefined`, or a {Promise} resolving to either.
-* `createWriteStream(key, value)` — Return a {Writable} to receive the response
-  body, or `undefined` if the response cannot be stored.
-* `delete(key)` — Remove all responses for `key`. May return a {Promise}.
-
-Returning a {Promise} from `get` or `delete` lets a store be backed by an
-asynchronous resource; the cache interceptor awaits these values, including on
-the revalidation and stale-while-revalidate paths.
-
-### `CacheKey`
-
-The request a response is being looked up or stored for.
-
-* `origin` {string} The request origin.
-* `method` {string} The request method.
-* `path` {string} The request path.
-* `headers` {Record<string, string|string[]>} The request headers, used to
-  satisfy `Vary`. (optional)
-
-### `CacheValue`
-
-The metadata of a cached response, excluding its body.
-
-* `statusCode` {number} The response's HTTP status code.
-* `statusMessage` {string} The response's HTTP status message.
-* `headers` {Record<string, string|string[]>} The response headers.
-* `vary` {Record<string, string|string[]|null>} The header names listed in the
-  response's `Vary` header mapped to the values they had in the original
-  request. A value is `null` when that header was absent from the original
-  request. (optional)
-* `etag` {string} The response's entity tag. (optional)
-* `cacheControlDirectives` {Object} The parsed `Cache-Control` directives of the
-  response. (optional)
-* `cachedAt` {number} The time, in milliseconds, at which the response was
-  cached.
-* `staleAt` {number} The time, in milliseconds, at which the response becomes
-  stale.
-* `deleteAt` {number} The time, in milliseconds, at which the response must be
-  evicted. A store must not return a response once this time has passed.
-
-The `vary` map drives response selection. For a response such as:
-
-```http
-Vary: content-encoding, accept
-content-encoding: utf8
-accept: application/json
-```
-
-the recorded map is:
-
-```js
-{
-  'content-encoding': 'utf8',
-  accept: 'application/json'
-}
-```
-
-If the original request did not include the `accept` header, its value is
-recorded as `null`:
-
-```js
-{
-  'content-encoding': 'utf8',
-  accept: null
-}
-```
-
-### `GetResult`
-
-The value returned by `get`. It contains every field of
-[`CacheValue`](#cachevalue) plus the response body.
-
-* `body` {Readable|Iterable|AsyncIterable|Buffer|string} The cached response
-  body. (optional)
-
-[RFC&nbsp;9111]: https://www.rfc-editor.org/rfc/rfc9111.html
-[`node:sqlite`]: https://nodejs.org/api/sqlite.html

package/node_modules/undici/docs/docs/api/ClientStats.md

@@ -1,93 +0,0 @@
-# ClientStats
-
-<!--introduced_in=v7.9.0-->
-<!--type=module-->
-<!-- source_link=lib/util/stats.js -->
-
-> Stability: 2 - Stable
-
-A `ClientStats` is a point-in-time snapshot of the connection and request
-state of a single [`Client`][]. Instances are not created directly; a fresh
-snapshot is produced each time the [`client.stats`][] getter is read.
-
-```mjs
-import { Client } from 'undici'
-
-const client = new Client('http://localhost:3000')
-const stats = client.stats
-console.log(stats.connected, stats.running)
-```
-
-```cjs
-const { Client } = require('undici')
-
-const client = new Client('http://localhost:3000')
-const stats = client.stats
-console.log(stats.connected, stats.running)
-```
-
-## Class: `ClientStats`
-
-<!-- YAML
-added: v7.9.0
--->
-
-Captures the connection and request counters of a [`Client`][] at the moment
-the snapshot is taken. The values are read from the client at construction time
-and do not update afterwards; read [`client.stats`][] again for current values.
-
-### `new ClientStats(client)`
-
-<!-- YAML
-added: v7.9.0
--->
-
-* `client` {Client} The client to read the statistics from.
-
-Creates a snapshot from the supplied `client`. This constructor is used
-internally by the [`client.stats`][] getter and is not normally invoked by
-application code.
-
-### `clientStats.connected`
-
-<!-- YAML
-added: v7.9.0
--->
-
-* Type: {boolean}
-
-`true` when the client currently has an open socket connection.
-
-### `clientStats.pending`
-
-<!-- YAML
-added: v7.9.0
--->
-
-* Type: {number}
-
-Number of open socket connections of this client that do not have an active
-request.
-
-### `clientStats.running`
-
-<!-- YAML
-added: v7.9.0
--->
-
-* Type: {number}
-
-Number of currently active requests of this client.
-
-### `clientStats.size`
-
-<!-- YAML
-added: v7.9.0
--->
-
-* Type: {number}
-
-Number of active, pending, or queued requests of this client.
-
-[`Client`]: Client.md#class-client
-[`client.stats`]: Client.md#clientstats