nano-benchmark 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2022, Eugene Lazutkin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder 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.

package/README.md

@@ -0,0 +1,99 @@
+# nano-benchmark [![NPM version][npm-img]][npm-url]
+
+[npm-img]:      https://img.shields.io/npm/v/nano-benchmark.svg
+[npm-url]:      https://npmjs.org/package/nano-benchmark
+
+`nano-benchmark` provides command-line utilities for benchmarking code and related statistical modules.
+
+Two utilities are available:
+
+* `nano-watch` — provides statistics in a streaming mode continuously running your code,
+  watching memory usage and updating the output.
+* `nano-bench` — runs benchmark tests on your code, calculating statistics and
+  statistical significance, and presenting them in a tabular format.
+
+The utilities are mostly used to measure performance of your code and compare it with other variants.
+It is geared toward benchmarking and performance tuning of a small fast snippets of code, e.g.,
+used in tight loops.
+
+## Visual samples
+
+### `nano-watch`
+
+![nano-watch](https://github.com/uhop/nano-bench/wiki/images/nano-watch-sample.png)
+
+### `nano-bench`
+
+![nano-bench](https://github.com/uhop/nano-bench/wiki/images/nano-bench-sample.png)
+
+## Installation
+
+```bash
+npm install --save nano-benchmark
+```
+
+### Deno and Bun support
+
+Both [deno](https://deno.land/) and [bun](https://bun.sh/) are supported.
+
+Don't forget to specify the appropriate permissions for Deno to run the benchmark scripts:
+`--allow-read` (required) and `--allow-hrtime` (optional but recommended).
+
+## Documentation
+
+Both utilities are available by name if you installed `nano-benchmark` globally
+(`npm install -g nano-benchmark`).
+If it is installed as a dependency, you can use utilities by name in the `scripts` section of
+your `package.json` file or from the command line by prefixing them with `npx`, e.g., `npx nano-watch`.
+
+Utilities are self-documented — run them with `--help` flag to learn about arguments.
+
+Both utilities import a module to benchmark using its (default) export.
+`nano-bench` assumes that it is an object with functional properties,
+which should be benchmarked and compared. `nano-watch` can use the same file format
+as `nano-bench` or it can use a single function.
+
+Example of a module for `nano-bench` called `bench-strings-concat.js`:
+
+```js
+export default {
+  strings: n => {
+    const a = 'a',
+      b = 'b';
+    for (let i = 0; i < n; ++i) {
+      const x = a + '-' + b;
+    }
+  },
+  backticks: n => {
+    const a = 'a',
+      b = 'b';
+    for (let i = 0; i < n; ++i) {
+      const x = `${a}-${b}`;
+    }
+  },
+  join: n => {
+    const a = 'a',
+      b = 'b';
+    for (let i = 0; i < n; ++i) {
+      const x = [a, b].join('-');
+    }
+  }
+};
+```
+
+The way to use it:
+
+```bash
+npx nano-bench bench-strings-concat.js
+npx nano-watch bench-strings-concat.js backticks
+```
+
+See [wiki](https://github.com/uhop/nano-bench/wiki) for more details.
+
+## License
+
+BSD 3-Clause License
+
+## Release history
+
+- 1.0.0: *Initial release.*

package/bin/nano-bench.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+
+import {Option, program} from 'commander';
+
+import {CURSOR_NORMAL, CURSOR_INVISIBLE, CLEAR_EOL} from 'console-toolkit/ansi';
+import {infinity, minus, multiplication} from 'console-toolkit/symbols.js';
+import {
+  abbrNumber,
+  compareDifference,
+  formatInteger,
+  formatNumber,
+  formatTime,
+  prepareTimeFormat
+} from 'console-toolkit/alphanumeric/number-formatters.js';
+import style, {c} from 'console-toolkit/style';
+import makeTable from 'console-toolkit/table';
+import lineTheme from 'console-toolkit/themes/lines/unicode-rounded.js';
+import Writer from 'console-toolkit/output/writer.js';
+import Updater from 'console-toolkit/output/updater.js';
+
+import {findLevel, benchmarkSeries, benchmarkSeriesPar} from '../src/bench/runner.js';
+import {bootstrap, getWeightedValue, mean} from '../src/stats.js';
+import mwtest from '../src/significance/mwtest.js';
+import kwtest from '../src/significance/kwtest.js';
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms)),
+  toInt = value => parseInt(value),
+  toFloat = value => parseFloat(value);
+
+program
+  .name('nano-bench')
+  .description('Small utility to benchmark and compare code.')
+  .version('1.0.0')
+  .argument('<file>', 'File to benchmark')
+  .option('-m, --ms <ms>', 'measurement time in milliseconds', toInt, 50)
+  .addOption(
+    new Option('-i, --iterations <iterations>', 'measurement iterations (overrides --ms)')
+      .conflicts('ms')
+      .argParser(toInt)
+  )
+  .option('--min-iterations <min-iterations>', 'minimum number of iterations', toInt, 1)
+  .option('-e, --export <name>', 'name of the export in the file', 'default')
+  .option('-a, --alpha <alpha>', 'significance level', toFloat, 0.05)
+  .option('-s, --samples <samples>', 'number of samples', toInt, 100)
+  .option('-p, --parallel', 'take samples in parallel asynchronously')
+  .option('-b, --bootstrap <bootstrap>', 'number of bootstrap samples', toInt, 1000)
+  .showHelpAfterError('(add --help to see available options)');
+
+program.parse();
+
+const options = program.opts(),
+  args = program.args;
+
+// validate the options
+
+if (options.minIterations < 1) program.error('The minimum number of iterations must be >= 1');
+if (options.alpha <= 0 || options.alpha >= 1)
+  program.error('The significance level must be > 0 and < 1');
+if (options.samples < 1) program.error('The number of samples must be >= 1');
+if (options.bootstrap < 1) program.error('The number of bootstrap samples must be >= 1');
+
+// open the file
+
+const fileName = new URL(args[0], `file://${process.cwd()}/`);
+
+let fns;
+try {
+  const file = await import(fileName);
+  fns = file[options.export];
+} catch (error) {
+  program.error(`File not found: ${args[0]} (${fileName})`);
+}
+
+if (!fns) program.error(`Export not found: ${options.export}`);
+
+const names = Object.keys(fns).filter(name => typeof fns[name] == 'function');
+if (names.length < 1) {
+  program.error('The exported object has no functions to measure');
+}
+
+// set up the writer and the updater
+
+const writer = new Writer();
+let updater;
+
+process.once('exit', () => updater?.done());
+process.once('SIGINT', async () => process.exit(130));
+process.once('SIGTERM', () => process.exit(143));
+
+// setup running the benchmark
+
+const numericSortingAsc = (a, b) => a - b;
+const getPercentile = weight => samples =>
+  getWeightedValue(samples.sort(numericSortingAsc), weight);
+
+const getStats = samples => {
+  samples.sort(numericSortingAsc);
+  const median = getWeightedValue(samples, 0.5),
+    lo = getWeightedValue(samples, options.alpha / 2),
+    hi = getWeightedValue(samples, 1 - options.alpha / 2);
+  return {median, lo, hi, bootstrap: false};
+};
+
+const getBootstrapStats = samples => {
+  const median = mean(bootstrap(getPercentile(0.5), samples, options.bootstrap)),
+    lo = mean(bootstrap(getPercentile(options.alpha / 2), samples, options.bootstrap)),
+    hi = mean(bootstrap(getPercentile(1 - options.alpha / 2), samples, options.bootstrap));
+  return {median, lo, hi, bootstrap: true};
+};
+
+const normalizeSamples = (samples, batchSize) => {
+  for (let i = 0; i < samples.length; ++i) {
+    samples[i] /= batchSize;
+  }
+  return samples;
+};
+
+const benchSeries = options.parallel ? benchmarkSeriesPar : benchmarkSeries;
+
+const bold = s => style.bold.text(s),
+  num = s => style.bright.yellow.text(s),
+  faster = s => style.bright.green.text(bold(s) + ' faster'),
+  slower = s => style.bright.red.text(bold(s) + ' slower');
+
+const rabbit = '\u{1f407}',
+  turtle = '\u{1f422}';
+
+let iterations = [];
+if (options.iterations > 0) {
+  iterations = new Array(names.length).fill(Math.max(options.iterations, options.minIterations));
+}
+
+await writer.write([
+  c`{{bold.save.bright.cyan}}${program.name()}{{restore}} {{save.bright.yellow}}${program.version()}{{restore}}: ${program.description()}`,
+  '',
+  c`Confidence interval: {{save.bright.yellow}}${formatNumber(100 * (1 - options.alpha), {
+    precision: 2
+  })}%{{restore}}, samples: {{save.bright.yellow}}${formatInteger(
+    options.samples
+  )}{{restore}}, bootstrap samples: {{save.bright.yellow}}${formatInteger(
+    options.bootstrap
+  )}{{restore}}`,
+  iterations.length
+    ? c`Measuring {{save.bright.yellow}}${formatInteger(
+        iterations[0]
+      )}{{restore}} iterations per sample ({{save.bright.yellow}}${formatInteger(
+        iterations[0] * options.samples
+      )}{{restore}} per function)`
+    : c`Measuring {{save.bright.yellow}}${formatTime(
+        options.ms,
+        prepareTimeFormat([options.ms], 1000)
+      )}{{restore}} per sample (~{{save.bright.yellow}}${formatTime(
+        options.ms * 2 * options.samples,
+        prepareTimeFormat([options.ms * 2 * options.samples], 1000)
+      )}{{restore}} per function)`,
+  ''
+]);
+
+const results = [],
+  stats = [];
+
+const tableHeader1 = [
+    {value: 'name', height: 2, align: 'dc'},
+    {value: 'time', width: 3, align: 'c'},
+    null,
+    null,
+    {value: 'op/s', height: 2, align: 'dc'},
+    {value: 'batch', height: 2, align: 'dc'}
+  ].map(cell => (cell ? {...cell, value: bold(cell.value)} : null)),
+  tableHeader2 = [
+    null,
+    {value: 'median', align: 'c'},
+    {value: '+', align: 'c'},
+    {value: minus, align: 'c'},
+    null,
+    null
+  ].map(cell => (cell ? {...cell, value: bold(cell.value)} : null));
+
+const makeTableData = () => {
+  const tableData = [tableHeader1, tableHeader2];
+  for (let i = 0; i < names.length; ++i) {
+    const row = [bold(names[i])],
+      s = stats[i];
+    if (s) {
+      const format = prepareTimeFormat([s.median - s.lo, s.median, s.hi - s.median], 1000);
+      row.push(
+        {value: bold(num(formatTime(s.median, format))), align: 'r'},
+        {value: num('+' + formatTime(s.hi - s.median, format)), align: 'r'},
+        {value: num(minus + formatTime(s.median - s.lo, format)), align: 'r'},
+        {value: num(abbrNumber(1000 / s.median)), align: 'r'}
+      );
+    } else if (i == stats.length) {
+      row.push({value: 'measuring...', width: 4}, null, null, null);
+    } else {
+      row.push(null, null, null, null);
+    }
+    row.push(i < iterations.length ? {value: num(abbrNumber(iterations[i])), align: 'r'} : null);
+    tableData.push(row);
+  }
+  return tableData;
+};
+
+// find the level
+
+const report = () => {
+  const tableData = makeTableData(),
+    table = makeTable(tableData, lineTheme);
+  table.vAxis[2] = 2;
+  return table.toStrings();
+};
+
+updater = new Updater(
+  report,
+  {prologue: CURSOR_INVISIBLE, epilogue: CURSOR_NORMAL, afterLine: CLEAR_EOL},
+  writer
+);
+
+while (iterations.length < names.length) {
+  const index = iterations.length,
+    fn = fns[names[index]];
+
+  iterations.push(0);
+
+  const batchSize = await findLevel(
+    fn,
+    {threshold: options.ms, startFrom: options.minIterations},
+    async (name, data) => {
+      if (name === 'finding-level-next') {
+        iterations[index] = data.n;
+        await updater.update();
+        await sleep(5);
+      }
+    }
+  );
+
+  iterations[index] = batchSize;
+  await updater.update();
+}
+
+// run the benchmark
+
+for (let i = 0; i < iterations.length; ++i) {
+  const batchSize = iterations[i],
+    samples = await benchSeries(fns[names[i]], batchSize, {nSeries: options.samples});
+  normalizeSamples(samples, batchSize);
+  results.push(samples);
+  stats.push(getStats(samples));
+  await updater.update();
+  await sleep(5);
+  stats[i] = getBootstrapStats(samples);
+  await updater.update();
+  await sleep(5);
+}
+
+await updater.final();
+updater = null;
+
+// calculate significance
+
+if (results.length > 1) {
+  let significance = null;
+
+  for (const samples of results) samples.sort(numericSortingAsc);
+  if (results.length == 2) {
+    const result = mwtest(results[0], results[1], options.alpha);
+    if (result.different)
+      significance = [
+        [false, result.different],
+        [result.different, false]
+      ];
+  } else {
+    const result = kwtest(results, options.alpha);
+    if (result.different) significance = result.groupDifference;
+  }
+
+  if (significance) {
+    const sortedStats = stats.slice().sort((a, b) => a.median - b.median),
+      tableData = [['  ', bold('#'), bold('name')]];
+    let rabbitIndex = -1,
+      turtleIndex = -1;
+    for (let i = 0; i < names.length; ++i) {
+      tableData[0].push({value: bold(formatInteger(i + 1)), align: 'c'});
+      const row = [null, formatInteger(i + 1), bold(names[i])],
+        signRow = significance[i];
+      for (let j = 0; j < signRow.length; ++j) {
+        if (signRow[j]) {
+          const result = compareDifference(stats[i].median, stats[j].median);
+          let text = '';
+          if (result.infinity) {
+            text = infinity;
+          } else if (result.percentage) {
+            text = result.percentage + '%';
+          } else if (result.ratio) {
+            text = result.ratio + multiplication;
+          }
+          if (text) {
+            text = result.less ? faster(text) : slower(text);
+            row.push({value: text, align: 'c'});
+          } else {
+            row.push(null);
+          }
+        } else {
+          row.push(null);
+        }
+      }
+      if (stats[i] === sortedStats[0]) {
+        row[0] = {value: '\t1', align: 'c'};
+      } else if (stats[i] === sortedStats[sortedStats.length - 1]) {
+        row[0] = {value: '\t2', align: 'c'};
+      }
+      tableData.push(row);
+    }
+    const table = makeTable(tableData, lineTheme);
+    table.vAxis[1] = 2;
+    writer.writeString(
+      c`\n{{save.bright.cyan.bold}}The difference is statistically significant:{{restore}}\n\n`
+    );
+    const tableStrings = table
+      .toStrings()
+      .map(line => line.replace(/\t(1|2)/g, m => (m[1] == '2' ? turtle : rabbit)));
+    writer.write(tableStrings);
+  } else {
+    writer.writeString('\nThe difference is not statistically significant.\n');
+  }
+}

package/bin/nano-watch.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+
+import {program} from 'commander';
+
+import {CURSOR_NORMAL, CURSOR_INVISIBLE, CLEAR_EOL} from 'console-toolkit/ansi';
+import {
+  abbrNumber,
+  formatInteger,
+  formatNumber,
+  formatTime,
+  prepareTimeFormat
+} from 'console-toolkit/alphanumeric/number-formatters.js';
+import style, {c} from 'console-toolkit/style';
+import makeTable from 'console-toolkit/table';
+import lineTheme from 'console-toolkit/themes/lines/unicode-rounded.js';
+import Writer from 'console-toolkit/output/writer.js';
+import Updater from 'console-toolkit/output/updater.js';
+
+import {findLevel, benchmark} from '../src/bench/runner.js';
+import {MedianCounter} from '../src/stream-median.js';
+import {StatCounter} from '../src/stream-stats.js';
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+program
+  .name('nano-watch')
+  .description('Small utility to continuously benchmark code.')
+  .version('1.0.0')
+  .argument('<file>', 'File to benchmark')
+  .argument('[method]', 'Method name to benchmark')
+  .option('-m, --ms <ms>', 'milliseconds per iteration', value => parseInt(value), 500)
+  .option('-i, --iterations <number>', 'number of iterations (default: Infinity)', value =>
+    parseInt(value)
+  )
+  .option('-e, --export <name>', 'name of the export in the file', 'default')
+  .showHelpAfterError('(add --help to see available options)');
+
+program.parse();
+
+const options = program.opts(),
+  args = program.args;
+
+const fileName = new URL(args[0], `file://${process.cwd()}/`);
+
+let fn;
+try {
+  const file = await import(fileName);
+  fn = file[options.export];
+} catch (error) {
+  program.error(`File not found: ${args[0]} (${fileName})`);
+}
+
+if (!fn) program.error(`Export not found: ${options.export}`);
+if (args[1]) fn = fn[args[1]];
+if (typeof fn != 'function')
+  program.error(
+    `Function not found (export: ${options.export}${args[1] ? `, method: ${args[1]}` : ''})`
+  );
+
+const iterations =
+  isNaN(options.iterations) || options.iterations <= 0 ? Infinity : options.iterations;
+
+const writer = new Writer();
+
+await writer.writeString(
+  c`{{bold.save.bright.cyan}}${program.name()}{{restore}} {{save.bright.yellow}}${program.version()}{{restore}}: ${program.description()}\n\n`
+);
+
+let updater;
+
+process.once('exit', () => updater?.done());
+process.once('SIGINT', async () => {
+  if (typeof updater?.finalFrame == 'function') await updater.finalFrame();
+  process.exit(0);
+});
+process.once('SIGTERM', () => process.exit(143));
+
+function reportFindLevel(state, level, time) {
+  switch (state) {
+    case 'active':
+      const format = prepareTimeFormat([time], 1000),
+        timeString = formatTime(time, format);
+      return c`Batch size: {{save.bright.cyan}}${abbrNumber(
+        level
+      )}{{restore}}, time: {{bright.cyan}}${timeString}`;
+    case 'finished':
+      return c`Batch size: {{bright.cyan}}${abbrNumber(
+        level
+      )}{{reset.all}} {{dim}}(use Ctrl+C to stop)\n`;
+  }
+  return [];
+}
+
+updater = new Updater(
+  reportFindLevel,
+  {prologue: CURSOR_INVISIBLE, epilogue: CURSOR_NORMAL, afterLine: CLEAR_EOL},
+  writer
+);
+
+const batchSize = await findLevel(fn, {threshold: options.ms}, async (name, data) => {
+  if (name === 'finding-level-next') {
+    await updater.update(undefined, data.n, data.time);
+    await sleep(5);
+  }
+});
+
+await updater.final(batchSize);
+updater = null;
+
+const medianCounter = new MedianCounter();
+const statCounter = new StatCounter();
+
+const showData = time => {
+  const m = process.memoryUsage(),
+    median = medianCounter.get(),
+    stdDev = Math.sqrt(statCounter.variance),
+    format = {
+      ...prepareTimeFormat([statCounter.mean, stdDev, median], 1000),
+      keepFractionAsIs: true
+    },
+    tableData = [
+      ['#', 'time', 'mean', 'stdDev', 'median', 'skewness', 'kurtosis'],
+      [style.bright.yellow.text(formatInteger(statCounter.count))]
+        .concat(
+          [time, statCounter.mean, stdDev, median]
+            .map(value => formatTime(value, format))
+            .map(value => style.bright.yellow.text(value))
+        )
+        .concat(
+          [statCounter.skewness, statCounter.kurtosis]
+            .map(value => formatNumber(value, {precision: 3}))
+            .map(value => style.bright.yellow.text(value))
+        ),
+      [
+        style.bold.text('op/s'),
+        style.bright.yellow.text(abbrNumber(1000 / time)),
+        style.bright.yellow.text(abbrNumber(1000 / statCounter.mean)),
+        null,
+        style.bright.yellow.text(abbrNumber(1000 / median)),
+        null,
+        null
+      ],
+      [
+        style.bold.text('memory'),
+        {
+          value: c`{{save.bold}}used:{{restore}} {{bright.cyan}}${abbrNumber(m.heapUsed)}`,
+          width: 2
+        },
+        null,
+        {
+          value: c`{{save.bold}}total:{{restore}} {{bright.cyan}}${abbrNumber(m.heapTotal)}`,
+          width: 2
+        },
+        null,
+        {
+          value: c`{{save.bold}}resident set size:{{restore}} {{bright.cyan}}${abbrNumber(m.rss)}`,
+          width: 2
+        },
+        null
+      ]
+    ],
+    table = makeTable(tableData, lineTheme, {hAlignDefault: 'r', states: {rowFirst: style.bold}});
+
+  table.vAxis[3] = 2;
+
+  return table.toStrings();
+};
+
+function reportBenchmark(state, time) {
+  switch (state) {
+    case 'active':
+    case 'finished': {
+      return showData(time);
+    }
+  }
+  return [];
+}
+
+updater = new Updater(
+  reportBenchmark,
+  {prologue: CURSOR_INVISIBLE, epilogue: CURSOR_NORMAL, afterLine: CLEAR_EOL},
+  writer
+);
+
+updater.finalFrame = () => updater.final(updater.data.time);
+
+for (let i = 0; i < iterations; ++i) {
+  const time = (await benchmark(fn, batchSize)) / batchSize;
+  medianCounter.add(time);
+  statCounter.add(time);
+
+  updater.data = {time};
+  await updater.update(undefined, time);
+  await sleep(5);
+}
+
+await updater.finalFrame();
+updater = null;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "nano-benchmark",
+  "version": "1.0.0",
+  "description": "Small utilities to benchmark code with Node.",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./*": "./src/*"
+  },
+  "bin": {
+    "nano-bench": "./bin/nano-bench.js",
+    "nano-watch": "./bin/nano-watch.js"
+  },
+  "scripts": {
+    "test": "tape6 --flags FO"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uhop/nano-bench.git"
+  },
+  "keywords": [
+    "benchmark",
+    "performance",
+    "statistics"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (https://www.lazutkin.com/)",
+  "license": "BSD-3-Clause",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/uhop"
+  },
+  "bugs": {
+    "url": "https://github.com/uhop/nano-bench/issues"
+  },
+  "homepage": "https://github.com/uhop/nano-bench#readme",
+  "files": [
+    "src"
+  ],
+  "devDependencies": {
+    "tape-six": "^0.9.6"
+  },
+  "tape6": {
+    "tests": [
+      "tests/test-*.*js"
+    ]
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "console-toolkit": "^1.2.0"
+  }
+}