Node.js v20.4.0 (Current)

import function assert(value: unknown, message?: string | Error): asserts value
An alias of 
{@link 
ok 
}
.
@sincev0.5.9@paramvalue The input that is checked for being truthy.assert from 'node:assert';
import { function test(name?: string, fn?: test.TestFn): Promise<void> (+3 overloads)
The `test()` function is the value imported from the `test` module. Each
invocation of this function results in reporting the test to the `TestsStream`.

The `TestContext` object passed to the `fn` argument can be used to perform
actions related to the current test. Examples include skipping the test, adding
additional diagnostic information, or creating subtests.

`test()` returns a `Promise` that fulfills once the test completes.
if `test()` is called within a suite, it fulfills immediately.
The return value can usually be discarded for top level tests.
However, the return value from subtests should be used to prevent the parent
test from finishing first and cancelling the subtest
as shown in the following example.

```js
test('top level test', async (t) => {
  // The setTimeout() in the following subtest would cause it to outlive its
  // parent test if 'await' is removed on the next line. Once the parent test
  // completes, it will cancel any outstanding subtests.
  await t.test('longer running subtest', async (t) => {
    return new Promise((resolve, reject) => {
      setTimeout(resolve, 1000);
    });
  });
});
```

The `timeout` option can be used to fail the test if it takes longer than `timeout` milliseconds to complete. However, it is not a reliable mechanism for
canceling tests because a running test might block the application thread and
thus prevent the scheduled cancellation.
@sincev18.0.0, v16.17.0@paramname The name of the test, which is displayed when reporting test results.
Defaults to the `name` property of `fn`, or `'<anonymous>'` if `fn` does not have a name.@paramoptions Configuration options for the test.@paramfn The function under test. The first argument to this function is a {@link TestContext } object.
If the test uses callbacks, the callback function is passed as the second argument.@returnFulfilled with `undefined` once the test completes, or immediately if the test runs within a suite.test } from 'node:test';

function test(name?: string, fn?: test.TestFn): Promise<void> (+3 overloads)
The `test()` function is the value imported from the `test` module. Each
invocation of this function results in reporting the test to the `TestsStream`.

The `TestContext` object passed to the `fn` argument can be used to perform
actions related to the current test. Examples include skipping the test, adding
additional diagnostic information, or creating subtests.

`test()` returns a `Promise` that fulfills once the test completes.
if `test()` is called within a suite, it fulfills immediately.
The return value can usually be discarded for top level tests.
However, the return value from subtests should be used to prevent the parent
test from finishing first and cancelling the subtest
as shown in the following example.

```js
test('top level test', async (t) => {
  // The setTimeout() in the following subtest would cause it to outlive its
  // parent test if 'await' is removed on the next line. Once the parent test
  // completes, it will cancel any outstanding subtests.
  await t.test('longer running subtest', async (t) => {
    return new Promise((resolve, reject) => {
      setTimeout(resolve, 1000);
    });
  });
});
```

The `timeout` option can be used to fail the test if it takes longer than `timeout` milliseconds to complete. However, it is not a reliable mechanism for
canceling tests because a running test might block the application thread and
thus prevent the scheduled cancellation.
@sincev18.0.0, v16.17.0@paramname The name of the test, which is displayed when reporting test results.
Defaults to the `name` property of `fn`, or `'<anonymous>'` if `fn` does not have a name.@paramoptions Configuration options for the test.@paramfn The function under test. The first argument to this function is a {@link TestContext } object.
If the test uses callbacks, the callback function is passed as the second argument.@returnFulfilled with `undefined` once the test completes, or immediately if the test runs within a suite.test('mocks setTimeout to be executed synchronously without having to actually wait for it', context: test.TestContextcontext => {
  const const fn: test.Mock<(...args: any[]) => undefined>fn = context: test.TestContextcontext.test.TestContext.mock: test.MockTracker
Each test provides its own MockTracker instance.mock.test.MockTracker.fn<(...args: any[]) => undefined>(original?: ((...args: any[]) => undefined) | undefined, options?: test.MockFunctionOptions): test.Mock<(...args: any[]) => undefined> (+1 overload)
This function is used to create a mock function.

The following example creates a mock function that increments a counter by one
on each invocation. The `times` option is used to modify the mock behavior such
that the first two invocations add two to the counter instead of one.

```js
test('mocks a counting function', (t) => {
  let cnt = 0;

  function addOne() {
    cnt++;
    return cnt;
  }

  function addTwo() {
    cnt += 2;
    return cnt;
  }

  const fn = t.mock.fn(addOne, addTwo, { times: 2 });

  assert.strictEqual(fn(), 2);
  assert.strictEqual(fn(), 4);
  assert.strictEqual(fn(), 5);
  assert.strictEqual(fn(), 6);
});
```
@sincev19.1.0, v18.13.0@paramoriginal An optional function to create a mock on.@paramimplementation An optional function used as the mock implementation for `original`. This is useful for creating mocks that exhibit one behavior for a specified number of calls and
then restore the behavior of `original`.@paramoptions Optional configuration options for the mock function.@returnThe mocked function. The mocked function contains a special `mock` property, which is an instance of {@link MockFunctionContext}, and can be used for inspecting and changing the
behavior of the mocked function.fn();
  // Optionally choose what to mock
  context: test.TestContextcontext.test.TestContext.mock: test.MockTracker
Each test provides its own MockTracker instance.mock.test.MockTracker.timers: test.MockTimerstimers.test.MockTimers.enable(options?: test.MockTimersOptions): void
Enables timer mocking for the specified timers.

**Note:** When you enable mocking for a specific timer, its associated
clear function will also be implicitly mocked.

**Note:** Mocking `Date` will affect the behavior of the mocked timers
as they use the same internal clock.

Example usage without setting initial time:

```js
import { mock } from 'node:test';
mock.timers.enable({ apis: ['setInterval', 'Date'], now: 1234 });
```

The above example enables mocking for the `Date` constructor, `setInterval` timer and
implicitly mocks the `clearInterval` function. Only the `Date` constructor from `globalThis`,
`setInterval` and `clearInterval` functions from `node:timers`, `node:timers/promises`, and `globalThis` will be mocked.

Example usage with initial time set

```js
import { mock } from 'node:test';
mock.timers.enable({ apis: ['Date'], now: 1000 });
```

Example usage with initial Date object as time set

```js
import { mock } from 'node:test';
mock.timers.enable({ apis: ['Date'], now: new Date() });
```

Alternatively, if you call `mock.timers.enable()` without any parameters:

All timers (`'setInterval'`, `'clearInterval'`, `'Date'`, `'setImmediate'`, `'clearImmediate'`, `'setTimeout'`, and `'clearTimeout'`)
will be mocked.

The `setInterval`, `clearInterval`, `setTimeout`, and `clearTimeout` functions from `node:timers`, `node:timers/promises`,
and `globalThis` will be mocked.
The `Date` constructor from `globalThis` will be mocked.

If there is no initial epoch set, the initial date will be based on 0 in the Unix epoch. This is `January 1st, 1970, 00:00:00 UTC`. You can
set an initial date by passing a now property to the `.enable()` method. This value will be used as the initial date for the mocked Date
object. It can either be a positive integer, or another Date object.
@sincev20.4.0enable(['setTimeout']);
  const const nineSecs: 9000nineSecs = 9000;
  function setTimeout<[]>(callback: () => void, delay?: number): NodeJS.Timeout (+2 overloads)
Schedules execution of a one-time `callback` after `delay` milliseconds.

The `callback` will likely not be invoked in precisely `delay` milliseconds.
Node.js makes no guarantees about the exact timing of when callbacks will fire,
nor of their ordering. The callback will be called as close as possible to the
time specified.

When `delay` is larger than `2147483647` or less than `1` or `NaN`, the `delay`
will be set to `1`. Non-integer delays are truncated to an integer.

If `callback` is not a function, a `TypeError` will be thrown.

This method has a custom variant for promises that is available using
`timersPromises.setTimeout()`.
@sincev0.0.1@paramcallback The function to call when the timer elapses.@paramdelay The number of milliseconds to wait before calling the
`callback`. **Default:** `1`.@paramargs Optional arguments to pass when the `callback` is called.@returnsfor use with `clearTimeout()`setTimeout(const fn: test.Mock<(...args: any[]) => undefined>fn, const nineSecs: 9000nineSecs);

  const const threeSeconds: 3000threeSeconds = 3000;
  context: test.TestContextcontext.test.TestContext.mock: test.MockTracker
Each test provides its own MockTracker instance.mock.test.MockTracker.timers: test.MockTimerstimers.test.MockTimers.tick(milliseconds: number): void
Advances time for all mocked timers.

**Note:** This diverges from how `setTimeout` in Node.js behaves and accepts
only positive numbers. In Node.js, `setTimeout` with negative numbers is
only supported for web compatibility reasons.

The following example mocks a `setTimeout` function and
by using `.tick` advances in
time triggering all pending timers.

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();

  context.mock.timers.enable({ apis: ['setTimeout'] });

  setTimeout(fn, 9999);

  assert.strictEqual(fn.mock.callCount(), 0);

  // Advance in time
  context.mock.timers.tick(9999);

  assert.strictEqual(fn.mock.callCount(), 1);
});
```

Alternativelly, the `.tick` function can be called many times

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();
  context.mock.timers.enable({ apis: ['setTimeout'] });
  const nineSecs = 9000;
  setTimeout(fn, nineSecs);

  const twoSeconds = 3000;
  context.mock.timers.tick(twoSeconds);
  context.mock.timers.tick(twoSeconds);
  context.mock.timers.tick(twoSeconds);

  assert.strictEqual(fn.mock.callCount(), 1);
});
```

Advancing time using `.tick` will also advance the time for any `Date` object
created after the mock was enabled (if `Date` was also set to be mocked).

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();

  context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
  setTimeout(fn, 9999);

  assert.strictEqual(fn.mock.callCount(), 0);
  assert.strictEqual(Date.now(), 0);

  // Advance in time
  context.mock.timers.tick(9999);
  assert.strictEqual(fn.mock.callCount(), 1);
  assert.strictEqual(Date.now(), 9999);
});
```
@sincev20.4.0tick(const threeSeconds: 3000threeSeconds);
  context: test.TestContextcontext.test.TestContext.mock: test.MockTracker
Each test provides its own MockTracker instance.mock.test.MockTracker.timers: test.MockTimerstimers.test.MockTimers.tick(milliseconds: number): void
Advances time for all mocked timers.

**Note:** This diverges from how `setTimeout` in Node.js behaves and accepts
only positive numbers. In Node.js, `setTimeout` with negative numbers is
only supported for web compatibility reasons.

The following example mocks a `setTimeout` function and
by using `.tick` advances in
time triggering all pending timers.

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();

  context.mock.timers.enable({ apis: ['setTimeout'] });

  setTimeout(fn, 9999);

  assert.strictEqual(fn.mock.callCount(), 0);

  // Advance in time
  context.mock.timers.tick(9999);

  assert.strictEqual(fn.mock.callCount(), 1);
});
```

Alternativelly, the `.tick` function can be called many times

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();
  context.mock.timers.enable({ apis: ['setTimeout'] });
  const nineSecs = 9000;
  setTimeout(fn, nineSecs);

  const twoSeconds = 3000;
  context.mock.timers.tick(twoSeconds);
  context.mock.timers.tick(twoSeconds);
  context.mock.timers.tick(twoSeconds);

  assert.strictEqual(fn.mock.callCount(), 1);
});
```

Advancing time using `.tick` will also advance the time for any `Date` object
created after the mock was enabled (if `Date` was also set to be mocked).

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();

  context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
  setTimeout(fn, 9999);

  assert.strictEqual(fn.mock.callCount(), 0);
  assert.strictEqual(Date.now(), 0);

  // Advance in time
  context.mock.timers.tick(9999);
  assert.strictEqual(fn.mock.callCount(), 1);
  assert.strictEqual(Date.now(), 9999);
});
```
@sincev20.4.0tick(const threeSeconds: 3000threeSeconds);
  context: test.TestContextcontext.test.TestContext.mock: test.MockTracker
Each test provides its own MockTracker instance.mock.test.MockTracker.timers: test.MockTimerstimers.test.MockTimers.tick(milliseconds: number): void
Advances time for all mocked timers.

**Note:** This diverges from how `setTimeout` in Node.js behaves and accepts
only positive numbers. In Node.js, `setTimeout` with negative numbers is
only supported for web compatibility reasons.

The following example mocks a `setTimeout` function and
by using `.tick` advances in
time triggering all pending timers.

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();

  context.mock.timers.enable({ apis: ['setTimeout'] });

  setTimeout(fn, 9999);

  assert.strictEqual(fn.mock.callCount(), 0);

  // Advance in time
  context.mock.timers.tick(9999);

  assert.strictEqual(fn.mock.callCount(), 1);
});
```

Alternativelly, the `.tick` function can be called many times

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();
  context.mock.timers.enable({ apis: ['setTimeout'] });
  const nineSecs = 9000;
  setTimeout(fn, nineSecs);

  const twoSeconds = 3000;
  context.mock.timers.tick(twoSeconds);
  context.mock.timers.tick(twoSeconds);
  context.mock.timers.tick(twoSeconds);

  assert.strictEqual(fn.mock.callCount(), 1);
});
```

Advancing time using `.tick` will also advance the time for any `Date` object
created after the mock was enabled (if `Date` was also set to be mocked).

```js
import assert from 'node:assert';
import { test } from 'node:test';

test('mocks setTimeout to be executed synchronously without having to actually wait for it', (context) => {
  const fn = context.mock.fn();

  context.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
  setTimeout(fn, 9999);

  assert.strictEqual(fn.mock.callCount(), 0);
  assert.strictEqual(Date.now(), 0);

  // Advance in time
  context.mock.timers.tick(9999);
  assert.strictEqual(fn.mock.callCount(), 1);
  assert.strictEqual(Date.now(), 9999);
});
```
@sincev20.4.0tick(const threeSeconds: 3000threeSeconds);

  function assert(value: unknown, message?: string | Error): asserts value
An alias of 
{@link 
ok 
}
.
@sincev0.5.9@paramvalue The input that is checked for being truthy.assert.function assert.strictEqual<1>(actual: unknown, expected: 1, message?: string | Error): asserts actual is 1
Tests strict equality between the `actual` and `expected` parameters as
determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).

```js
import assert from 'node:assert/strict';

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1);
// OK

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1;
const oranges = 2;
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical
```

If the values are not strictly equal, an `AssertionError` is thrown with a `message` property set equal to the value of the `message` parameter. If the `message` parameter is undefined, a
default error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown
instead of the `AssertionError`.
@sincev0.1.21strictEqual(const fn: test.Mock<(...args: any[]) => undefined>fn.mock: test.MockFunctionContext<(...args: any[]) => undefined>mock.test.MockFunctionContext<(...args: any[]) => undefined>.callCount(): number
This function returns the number of times that this mock has been invoked. This
function is more efficient than checking `ctx.calls.length` because `ctx.calls` is a getter that creates a copy of the internal call tracking array.
@sincev19.1.0, v18.13.0@returnThe number of times that this mock has been invoked.callCount(), 1);
});

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

d41a6396dbb29dbeab84d8bc8916bf9ddb6564793f2ac907868023e0ed53bb5a  node-v20.4.0-aix-ppc64.tar.gz
aebab3e1a9a9e36cf42262f525440fa107f62f528681691c4640673e3b1d860e  node-v20.4.0-arm64.msi
34f51397b6aad957b1a8eb70d13da5baf357ead124c1e429a7e939aa61266c06  node-v20.4.0-darwin-arm64.tar.gz
60b39a297eb673ef07c8fbc620be545269a3bb3f13d0aefa50185bde0b0b0eb1  node-v20.4.0-darwin-arm64.tar.xz
fe765474a8651b85cee04a64e8473089196b922a36621f464a985a5f4891a054  node-v20.4.0-darwin-x64.tar.gz
5587e6dc98f5ac64ae568468419092c937fa4dec3af91d2d8a18b2255769a88f  node-v20.4.0-darwin-x64.tar.xz
7f917743676afae38f9027b2d8d8b85fbc0e213bf3dc7b0dc54de4d8a02f41d7  node-v20.4.0-headers.tar.gz
8a5f76a2fd6552f537461d1c2538a1a350b6b7ae38a1daa84fff74e3fab355e7  node-v20.4.0-headers.tar.xz
6ed340475a8bd5db5f04fe943b8fb89b7b2a8fd919f91217c6386dfa59865ba3  node-v20.4.0-linux-arm64.tar.gz
757f9c541f3e5da6e5ce06813d0ba206d4d013c008d7c59a7411512c1abfd0be  node-v20.4.0-linux-arm64.tar.xz
9b7e8d9ecffcb9039cb3cc7d51181f1f8ae9072a738787e5bb5994a8f3f548c3  node-v20.4.0-linux-armv7l.tar.gz
29f9d67081c3a811b02786d2a9f9288c2a576ec2cb8f62acfe294a8d62f6b1b7  node-v20.4.0-linux-armv7l.tar.xz
71bef4eb631ccd0129f14066ed963613f59772b1f804ad99e06f4d25a5178cf0  node-v20.4.0-linux-ppc64le.tar.gz
d7ef827dd81536f8c52eca6e2688574bff53328754ccbcf23ec0a49f366be2cc  node-v20.4.0-linux-ppc64le.tar.xz
0a60c9b6b9430a004a8dcbf31b59c41bd406ed7ed66fbf2537ffab58cb12d918  node-v20.4.0-linux-s390x.tar.gz
1a2fed46ad35821fb4a4e0a6ba0682a4cac76bd59c9bed271128da9b608933a8  node-v20.4.0-linux-s390x.tar.xz
2a9b03dd17fa6d9241b93e244d7e8f2524c4019fb5cfe3a99e59da1ee983cb9a  node-v20.4.0-linux-x64.tar.gz
6b49a007f409fb7620350285cfc909fbc909604fd0ff5a87a1730365514b3712  node-v20.4.0-linux-x64.tar.xz
5b787126a671595ea0b4aa03dc9c6aaaccb2f4f1649c171afd1c3fe70bf3e1f9  node-v20.4.0.pkg
ee5a8b8fc18e57e1613480f4d87734190b9d3873b9c4696badf74bbc8310469d  node-v20.4.0.tar.gz
09bd0b73c526b63c029d5ddfd885d10962e7ad87c975b94583c1f8ce90ee5348  node-v20.4.0.tar.xz
e5dc496965f5a5699d3c29ac8ee93574f051655d7c03201aba1419f7150087ad  node-v20.4.0-win-arm64.7z
ee84dba7bc7bf25977cca5bf83bf8fcab8e46f36efd7ccbe54e3d62eebb42518  node-v20.4.0-win-arm64.zip
97bf0aecb90aa5907fa4a7afdf8dde0a08f4f37043525c22a79d5f0512dfa4c1  node-v20.4.0-win-x64.7z
91a51aaa9152db510704b4274cffd84c6e3572e1678e055e0d9c5cf7951ebc2a  node-v20.4.0-win-x64.zip
61cf8648275341e5f144749d11779087d73aa9f58e059d08fce6edbb1217b49d  node-v20.4.0-win-x86.7z
d5483af890061e3b068077fa46d31a6948e62c3fb6bceaa6d453537de79cd126  node-v20.4.0-win-x86.zip
3e3ccf5f9c32e52a4f8631dfdbe5cc44eee9d891d05fdd8d0b1359f00b7f9013  node-v20.4.0-x64.msi
3db2515d260fd2568e715896044f7e3d41dc8a4d0a10604c77466c160096f59a  node-v20.4.0-x86.msi
691013e2f9687732ffbcfaaa5a59f6bad669266354f9da25088bc328ce5e70b1  win-arm64/node.exe
26977faa070f622c775ac338b51aae98a410b42e7eadeeecfc7f9893ead83d29  win-arm64/node.lib
13f10b8230ea61207589dcb075ab6706b1bf94b4c30e5b62cfbf62d34a047055  win-arm64/node_pdb.7z
aa91088403af0cf43d35272b9bd36e6a41effbbaef276c1e26cea0c04170de06  win-arm64/node_pdb.zip
8419696dafcdd2c8ab41a0e3cc3c731933f47beee3da8459d802ef53332b867c  win-x64/node.exe
634e16fe60b1c7a043c53cea124af0b4122e3a8d6cbda5130f58593dfae3d50b  win-x64/node.lib
f51c6b94dcb1c5f683255e89463b3bc909774a0d0f7d9117e68a688e535e3b4f  win-x64/node_pdb.7z
c2bd95feceaeae6e10f081d5d1c7beb0e619b3a9ca920ec01b952e48442e51ef  win-x64/node_pdb.zip
fc6d68673f6582c0ef04caad96ead0e40832e060fd89f483d442201c97a7e6ae  win-x86/node.exe
200b17477721475de86ddabbdecd5970c59723b74890c19398fdc47013593af5  win-x86/node.lib
0b7d7c7666bb81b008257a5cda9e2d5ba25d4a5623d87b62963ba221c8b12036  win-x86/node_pdb.7z
3dc2a339c5535218b79e95bfb5759c5e36757001e1236953da86f40e20855fb3  win-x86/node_pdb.zip
-----BEGIN PGP SIGNATURE-----

iQGzBAEBCAAdFiEEiQwI24V5Fi/uDfnbi+q0389VXvQFAmSldu8ACgkQi+q0389V
XvQrYQv9GJkxaG49BxIknAhkP05PF/H2HMqXy+jY9uJy9xAROsfBwKw8k+aMue7S
dF3xRZB3NIALZNptTDFoqu0GplcC0xUNPJr2/MAzVEX9neXEnzHtvfxd1bH/8wlz
sOUBB3degVeF/fcuWbbTA4Lq9MibAmVmm5YDXQjQpLC7jaWmuOqJvWz2qiqiP8d8
mLG+x7u36uGPXVkEFFwfjw8QabQ3FszQVM5vTbr1jdJsYUVd+k6ag9mOaRs0sB8O
CUC1ZYCXSf8CcTLziZLXB0GYMswR656LHJO7CrVgpRyi21SsF/z0f+XVjDdsrYtC
7yINviNo9Q1xBJYL5hrQYFxa8lg60ujOZIFwUfMu+S4ZSFROxHpS2x2vg93m8ON8
qbxWMx1H8dj7ubBOSOY3aXnC+WFDbt9TLu9CApvqZ27tsLjGhSi/mjNPqqT97Ek0
Bsf8o8BuAsWi3LOt11t5Mpn5H51GsLJ+9NvN5kMh0KgUgi/+qc5xeGbFUh8HaHU0
7sHCBsHg
=P4sp
-----END PGP SIGNATURE-----