rman 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 sqbjs
+
+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/README.md

@@ -0,0 +1,101 @@
+## postgresql-client
+  
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+
+Professional PostgreSQL client written in TypeScript.
+
+## Features
+
+- Pure JavaScript library completely written in TypeScript
+- Supports both single connection and pooling
+- Named Prepared Statements
+- Extended cursor support with fast double-link cache
+- Extensible data-types and type mapping
+- Extended bind parameters
+- Multidimensional arrays with fast binary encoding/decoding
+- Low memory utilization and boosted performance with Shared Buffers
+- Full binary and text wire protocol support for all data types
+- Supports Clear text, MD5 and SASL password algorithms
+- Can return both array and object rows
+- Asynchronous Promise based api
+- Strictly typed
+
+## Installation
+
+```bash
+$ npm install postgresql-client --save
+```
+
+## Documentation
+Documentation for detailed usage is [here](DOCUMENTATION.md)
+
+```ts
+import {Connection} from 'postgresql-client';
+
+const connection = new Connection('postgres://localhost');
+await connection.connect();
+const result = await connection.query(
+    'select * from cities where name like $1',
+    {params: ['%york%']});
+const rows = result.rows;
+await connection.close(); // Disconnect
+```
+
+```ts
+import {Pool} from 'postgresql-client';
+
+const db = new Pool({
+    host: 'postgres://localhost',
+    pool: {
+       min: 1,
+       max: 10,
+       idleTimeoutMillis: 5000
+    }
+});
+
+const result = await db.query(
+    'select * from cities where name like $1',
+    {params: ['%york%'], cursor: true});
+const cursor = result.cursor;
+let row;
+while ((row = cursor.next())) {
+  console.log(row);
+}
+
+await db.close(); // Disconnect all connections and shutdown pool
+```
+
+
+## Support
+You can report bugs and discuss features on the [GitHub issues](https://github.com/panates/postgresql-client/issues) page
+When you open an issue please provide version of NodeJS and PostgreSQL server.
+
+
+## Node Compatibility
+
+- node >= 10.x
+ 
+  
+### License
+postgresql-client is available under [MIT](LICENSE) license.
+
+[npm-image]: https://img.shields.io/npm/v/postgresql-client.svg
+[npm-url]: https://npmjs.org/package/postgresql-client
+[travis-image]: https://img.shields.io/travis/panates/postgresql-client/master.svg
+[travis-url]: https://travis-ci.com/panates/postgresql-client
+[coveralls-image]: https://img.shields.io/coveralls/panates/postgresql-client/master.svg
+[coveralls-url]: https://coveralls.io/r/panates/postgresql-client
+[downloads-image]: https://img.shields.io/npm/dm/postgresql-client.svg
+[downloads-url]: https://npmjs.org/package/postgresql-client
+[gitter-image]: https://badges.gitter.im/panates/postgresql-client.svg
+[gitter-url]: https://gitter.im/panates/postgresql-client?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[dependencies-image]: https://david-dm.org/panates/postgresql-client/status.svg
+[dependencies-url]:https://david-dm.org/panates/postgresql-client
+[devdependencies-image]: https://david-dm.org/panates/postgresql-client/dev-status.svg
+[devdependencies-url]:https://david-dm.org/panates/postgresql-client?type=dev
+[quality-image]: http://npm.packagequality.com/shield/postgresql-client.png
+[quality-url]: http://packagequality.com/#?package=postgresql-client

package/bin/debug.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import {run} from '../src/cli.js';
+
+run().catch(e => console.error(e));

package/bin/rman.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import {run} from '../dist/cli.js';
+
+// eslint-disable-next-line
+run().catch(e => console.error(e));

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function run(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,51 @@
+import fs from 'fs/promises';
+import { URL } from 'url';
+import chalk from 'chalk';
+import { program } from "commander";
+import { Workspace } from './workspace/workspace.js';
+export async function run(argv = process.argv) {
+    const pkgJson = JSON.parse(await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
+    program.version(pkgJson.version || '');
+    program
+        .command('run <script>')
+        .description('Executes given script for every package in repository')
+        .action(async (script) => runScript(script))
+        .allowUnknownOption();
+    program
+        .command('build')
+        .description('Executes "build" script for every package in repository')
+        .action(async () => runScript('build'))
+        .allowUnknownOption();
+    program
+        .command('lint')
+        .description('Executes "lint" script for every package in repository')
+        .action(async () => runScript('lint'))
+        .allowUnknownOption();
+    program
+        .command('test')
+        .description('Executes "test" script for every package in repository')
+        .action(async () => runScript('lint'))
+        .allowUnknownOption();
+    program.parse(argv);
+}
+async function runScript(script) {
+    const workspace = await Workspace.resolve();
+    const result = await workspace.runScript(script, {
+        gauge: true
+    });
+    if (result.errorCount) {
+        console.error('\n' + chalk.yellow(result.errorCount) + chalk.white(' error(s)'));
+        let s = '';
+        for (let i = 0; i < result.commands.length; i++) {
+            const cmd = result.commands[i];
+            if (cmd.error) {
+                s += '\n' + (i + 1) + ') ' +
+                    chalk.cyanBright(cmd.package) + '\n' +
+                    chalk.white(cmd.command) + '\n' +
+                    chalk.red('Error: ' + cmd.error.message) + '\n' +
+                    chalk.red(cmd.stderr) + '\n';
+            }
+        }
+        console.error(s);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './workspace/workspace';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './workspace/workspace';

package/dist/workspace/executor.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+export interface IExecutorOptions {
+    stdio?: 'inherit' | 'pipe';
+    cwd?: string;
+    argv?: string[];
+    env?: Record<string, string | undefined>;
+    shell?: boolean;
+    color?: boolean;
+    onSpawn?: (childProcess: ChildProcess) => void;
+    onLine?: (line: string, stdio: 'stderr' | 'stdout') => void;
+    onData?: (data: string, stdio: 'stderr' | 'stdout') => void;
+}
+export interface IRunScriptOptions {
+    gauge?: boolean;
+}
+export interface ExecuteCommandResult {
+    code?: number;
+    error?: any;
+    stderr: string;
+    stdout: string;
+}
+export declare function executeCommand(command: string, options?: IExecutorOptions): Promise<ExecuteCommandResult>;

package/dist/workspace/executor.js

@@ -0,0 +1,107 @@
+import { spawn } from 'child_process';
+import npmRubPath from 'npm-run-path';
+import chalk from 'chalk';
+import { onProcessExit } from './utils.js';
+const runningChildren = new Map();
+export async function executeCommand(command, options) {
+    const opts = {
+        ...options
+    };
+    opts.env = {
+        ...npmRubPath.env({ cwd: options?.cwd }),
+        //        FORCE_COLOR: `${chalk.level}`,
+        ...opts.env
+    };
+    opts.cwd = opts.cwd || process.cwd();
+    opts.color = opts.color == null ? true : opts.color;
+    const spawnOptions = {
+        stdio: opts.stdio || 'pipe',
+        env: opts.env,
+        cwd: opts.cwd,
+        shell: options?.shell,
+        windowsHide: true
+    };
+    const result = {
+        code: undefined,
+        stderr: '',
+        stdout: ''
+    };
+    const buffer = {
+        stdout: '',
+        stderr: ''
+    };
+    const processData = (data, stdio) => {
+        buffer[stdio] += data;
+        result[stdio] += data;
+        if (opts.onData)
+            opts.onData(data, stdio);
+    };
+    const processLines = (stdio, flush) => {
+        let chunk = buffer[stdio];
+        let i;
+        if (flush && !chunk.endsWith('\n'))
+            chunk += '\n';
+        while ((i = chunk.indexOf('\n')) >= 0) {
+            const line = chunk.substring(0, i);
+            chunk = chunk.substring(i + 1);
+            if (opts.onLine)
+                opts.onLine(line, stdio);
+        }
+        buffer[stdio] = chunk;
+    };
+    const child = spawn(command, opts.argv || [], spawnOptions);
+    if (child.pid) {
+        runningChildren.set(child.pid, child);
+        if (opts.onSpawn)
+            opts.onSpawn(child);
+    }
+    child.stdout?.on('data', (data) => {
+        processData(data, 'stdout');
+        processLines('stdout');
+    });
+    child.stderr?.on('data', (data) => {
+        processData(data, 'stderr');
+        processLines('stderr');
+    });
+    return new Promise(resolve => {
+        let resolved;
+        child.on('error', (err) => {
+            if (child.pid)
+                runningChildren.delete(child.pid);
+            processLines('stdout', true);
+            processLines('stderr', true);
+            if (resolved)
+                return;
+            result.code = err.code || 1;
+            result.error = err;
+            if (!result.error) {
+                const text = `Command failed (${result.code})`;
+                result.error =
+                    new Error((opts.color ? chalk.red(text) : text) + '\n  ' +
+                        opts.color ? chalk.white(err.message) : err.message);
+            }
+            resolved = true;
+            resolve(result);
+        });
+        child.on('close', (code) => {
+            if (child.pid)
+                runningChildren.delete(child.pid);
+            processLines('stdout', true);
+            processLines('stderr', true);
+            if (resolved)
+                return;
+            result.code = code;
+            resolved = true;
+            if (code) {
+                const text = `Command failed (${result.code})`;
+                result.error = new Error((opts.color ? chalk.red(text) : text));
+            }
+            return resolve(result);
+        });
+    });
+}
+onProcessExit(() => {
+    runningChildren.forEach((child) => {
+        child.kill();
+    });
+});

package/dist/workspace/package.d.ts

@@ -0,0 +1,27 @@
+export interface RunScriptResult {
+    script: string;
+    code?: number;
+    errorCount: number;
+    commands: CommandResult[];
+}
+export interface ScriptCommand {
+    name: string;
+    command: string;
+    step: string;
+}
+export interface CommandResult {
+    package: string;
+    command: string;
+    code: number;
+    error: any;
+    stdout: string;
+    stderr: string;
+}
+export declare class Package {
+    readonly dirname: string;
+    readonly def: any;
+    dependencies: string[];
+    constructor(dirname: string, def: any);
+    get name(): string;
+    getScriptCommands(script: string): ScriptCommand[];
+}

package/dist/workspace/package.js

@@ -0,0 +1,36 @@
+import parseNpmScript from '@netlify/parse-npm-script';
+export class Package {
+    constructor(dirname, def) {
+        this.dirname = dirname;
+        this.dependencies = [];
+        Object.defineProperty(this, 'def', {
+            enumerable: false,
+            value: def,
+        });
+    }
+    get name() {
+        return this.def.name;
+    }
+    getScriptCommands(script) {
+        const result = [];
+        let scriptInfo;
+        try {
+            scriptInfo = parseNpmScript(this.def, 'npm run ' + script);
+        }
+        catch {
+            return result;
+        }
+        if (scriptInfo && scriptInfo.raw)
+            for (const step of scriptInfo.steps) {
+                const parsed = Array.isArray(step.parsed) ? step.parsed : [step.parsed];
+                for (const cmd of parsed) {
+                    result.push({
+                        name: cmd.split(' ')[0],
+                        command: cmd,
+                        step: step.name
+                    });
+                }
+            }
+        return result;
+    }
+}

package/dist/workspace/providers/npm-provider.d.ts

@@ -0,0 +1,4 @@
+import { IParsedWorkspaceInfo, IWorkspaceProvider } from '../types';
+export declare class NpmProvider implements IWorkspaceProvider {
+    parse(root: string): Promise<IParsedWorkspaceInfo | undefined>;
+}

package/dist/workspace/providers/npm-provider.js

@@ -0,0 +1,12 @@
+import { getPackageJson } from '../utils.js';
+export class NpmProvider {
+    async parse(root) {
+        const pkg = getPackageJson(root);
+        if (pkg && typeof pkg.workspaces === 'object') {
+            if (Array.isArray(pkg.workspaces))
+                return { root, packages: pkg.workspaces };
+            if (Array.isArray(pkg.workspaces.packages))
+                return { root, packages: pkg.workspaces.packages };
+        }
+    }
+}

package/dist/workspace/types.d.ts

@@ -0,0 +1,11 @@
+export interface IWorkspaceOptions {
+    packageOrder?: string[];
+    scripts?: Record<string, {}>;
+}
+export interface IWorkspaceProvider {
+    parse: (root: string) => Promise<IParsedWorkspaceInfo | undefined>;
+}
+export interface IParsedWorkspaceInfo {
+    root: string;
+    packages: string[];
+}

package/dist/workspace/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workspace/utils.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare type ExitListener = (signal: NodeJS.Signals | "exit") => void;
+export declare function getPackageJson(dirname: string): any;
+export declare function onProcessExit(listener: ExitListener, forceExit?: boolean): void;
+export declare function setFind<T>(set: Set<T>, cb: (item: T) => boolean): T | undefined;
+export {};

package/dist/workspace/utils.js

@@ -0,0 +1,22 @@
+import path from 'path';
+import fs from 'fs';
+export function getPackageJson(dirname) {
+    const f = path.resolve(dirname, 'package.json');
+    if (!fs.existsSync(f))
+        return;
+    return JSON.parse(fs.readFileSync(f, 'utf-8'));
+}
+export function onProcessExit(listener, forceExit = true) {
+    ["SIGTERM", "SIGINT"].forEach((event) => process.once(event, (signal) => {
+        listener(signal);
+        if (forceExit)
+            process.exit(1);
+    }));
+    process.once("exit", () => listener("exit"));
+}
+export function setFind(set, cb) {
+    for (const e of set) {
+        if (cb(e))
+            return e;
+    }
+}

package/dist/workspace/workspace.d.ts

@@ -0,0 +1,16 @@
+import { IRunScriptOptions } from './executor.js';
+import { Package, RunScriptResult } from './package.js';
+import { IWorkspaceOptions } from './types.js';
+export declare class Workspace {
+    readonly root: string;
+    readonly packages: Package[];
+    private _options;
+    constructor(root: string, packages: Package[], options?: IWorkspaceOptions);
+    getPackage(name: string): Package | undefined;
+    runScript(script: string, options?: IRunScriptOptions): Promise<RunScriptResult>;
+    private _determineDependencies;
+    private _getSortedPackages;
+    static resolve(root?: string, options?: {
+        deep?: number;
+    }): Promise<Workspace>;
+}

package/dist/workspace/workspace.js

@@ -0,0 +1,227 @@
+import fs from 'fs';
+import glob from 'fast-glob';
+import path from 'path';
+import chalk from 'chalk';
+import { MultiBar, Presets } from 'cli-progress';
+import { getPackageJson, setFind } from './utils.js';
+import { executeCommand } from './executor.js';
+import { Package } from './package.js';
+import { NpmProvider } from './providers/npm-provider.js';
+const providers = [
+    new NpmProvider()
+];
+export class Workspace {
+    constructor(root, packages, options) {
+        this.root = root;
+        this.packages = packages;
+        this._options = { ...options };
+        this._determineDependencies();
+    }
+    getPackage(name) {
+        return this.packages.find(p => p.name === name);
+    }
+    async runScript(script, options = {}) {
+        const packages = {};
+        const result = {
+            script,
+            errorCount: 0,
+            commands: []
+        };
+        options.gauge = options.gauge == null ? true : options.gauge;
+        const progressBars = options.gauge && new MultiBar({
+            format: '[' + chalk.cyan('{bar}') + '] {percentage}% | {value}/{total} | ' +
+                chalk.yellowBright('{package}') + ' | ' + chalk.yellow('{command}'),
+            barsize: 30,
+            hideCursor: true
+        }, Presets.rect);
+        const overallProgress = progressBars && progressBars.create(0, 0);
+        let totalCommands = 0;
+        for (const p of this._getSortedPackages()) {
+            const commands = p.getScriptCommands(script);
+            const progress = progressBars && progressBars.create(commands.length, 0);
+            packages[p.name] = {
+                package: p,
+                commands: [...commands],
+                progress
+            };
+            totalCommands += commands.length;
+            if (progress)
+                progress.start(commands.length, 0, {
+                    package: p.name,
+                    command: 'Waiting'
+                });
+        }
+        if (overallProgress) {
+            overallProgress.start(totalCommands, 0, { package: 'Overall', command: '' });
+        }
+        const t = Date.now();
+        return new Promise((resolve) => {
+            const remaining = new Set(Object.keys(packages));
+            const runScripts = () => {
+                for (const pkgName of remaining) {
+                    const pkgInfo = packages[pkgName];
+                    const pkg = pkgInfo.package;
+                    const progress = pkgInfo.progress;
+                    for (let k = 0; k < pkgInfo.commands.length; k++) {
+                        const cmd = pkgInfo.commands[k];
+                        if (cmd.status === 'running')
+                            break;
+                        if (!cmd.status) {
+                            const concurrent = cmd.step.startsWith('pre');
+                            if (!concurrent &&
+                                pkg.dependencies.find(dep => setFind(remaining, p => p === dep))) {
+                                cmd.status = '';
+                                if (progress)
+                                    progress.update({ command: chalk.bgYellow.white('Waiting dependencies') });
+                                break;
+                            }
+                            cmd.status = 'running';
+                            if (progress)
+                                progress.update({ command: cmd.name });
+                            else
+                                console.log('[' + chalk.whiteBright(pkg.name) + ']  ' +
+                                    chalk.yellow(cmd.command), (chalk.cyanBright(' +' + (Date.now() - t))));
+                            void executeCommand(cmd.command, {
+                                ...options,
+                                cwd: pkg.dirname,
+                                shell: true
+                            }).then(r => {
+                                if (overallProgress)
+                                    overallProgress.increment(1);
+                                if (progress)
+                                    progress.increment(1);
+                                const cr = {
+                                    package: pkg.name,
+                                    command: cmd,
+                                    code: r.code || 1,
+                                    error: r.error,
+                                    stdout: r.stdout,
+                                    stderr: r.stderr
+                                };
+                                result.code = result.code || r.code;
+                                if (r.error)
+                                    result.errorCount++;
+                                result.commands.push(cr);
+                                cmd.status = 'done';
+                                if (r.error || k === pkgInfo.commands.length - 1) {
+                                    if (progress) {
+                                        if (r.error)
+                                            progress.update({ command: chalk.yellow(cmd.name) + chalk.red(' Filed!') });
+                                        else
+                                            progress.update({ command: chalk.green(' Completed!') });
+                                    }
+                                    remaining.delete(pkg.name);
+                                }
+                                if (!remaining.size) {
+                                    if (progressBars)
+                                        progressBars.stop();
+                                    return resolve(result);
+                                }
+                                if (!result.errorCount)
+                                    setTimeout(runScripts, 1);
+                            });
+                            if (!concurrent)
+                                break;
+                        }
+                    }
+                }
+            };
+            runScripts();
+        });
+    }
+    _determineDependencies() {
+        const deps = {};
+        for (const pkg of this.packages) {
+            const o = {
+                ...pkg.def.dependencies,
+                ...pkg.def.devDependencies,
+                ...pkg.def.peerDependencies,
+                ...pkg.def.optionalDependencies
+            };
+            const dependencies = [];
+            for (const k of Object.keys(o)) {
+                const p = this.getPackage(k);
+                if (p)
+                    dependencies.push(k);
+            }
+            deps[pkg.name] = dependencies;
+            pkg.dependencies = dependencies;
+        }
+        let circularCheck;
+        const deepFindDependencies = (pkg, target) => {
+            if (circularCheck.includes(pkg.name))
+                return;
+            circularCheck.push(pkg.name);
+            for (const s of pkg.dependencies) {
+                if (!target.includes(s)) {
+                    target.push(s);
+                    const p = this.getPackage(s);
+                    if (p) {
+                        deepFindDependencies(p, target);
+                    }
+                }
+            }
+        };
+        for (const pkg of this.packages) {
+            circularCheck = [];
+            deepFindDependencies(pkg, pkg.dependencies);
+        }
+    }
+    _getSortedPackages() {
+        const packages = [...this.packages];
+        const packageOrder = this._options.packageOrder;
+        packages.sort((a, b) => {
+            if (packageOrder) {
+                const a1 = packageOrder.indexOf(a.name);
+                const b1 = packageOrder.indexOf(b.name);
+                const i = (a1 >= 0 ? a1 : Number.MAX_SAFE_INTEGER) - (b1 >= 0 ? b1 : Number.MAX_SAFE_INTEGER);
+                if (i !== 0)
+                    return i;
+            }
+            if (b.dependencies.includes(a.name))
+                return -1;
+            if (a.dependencies.includes(b.name))
+                return 1;
+            return 0;
+        });
+        return packages;
+    }
+    static async resolve(root, options) {
+        root = root || process.cwd();
+        let deep = options?.deep || 0;
+        while (deep-- >= 0 && fs.existsSync(root)) {
+            for (let i = providers.length - 1; i >= 0; i--) {
+                const provider = providers[i];
+                const inf = await provider.parse(root);
+                if (!inf)
+                    continue;
+                const pkgJson = getPackageJson(inf.root);
+                if (!pkgJson)
+                    continue;
+                const packages = [];
+                for (const pattern of inf.packages) {
+                    const dirs = await glob(pattern, {
+                        cwd: inf.root,
+                        absolute: true,
+                        deep: 0,
+                        onlyDirectories: true
+                    });
+                    for (const dir of dirs) {
+                        const p = await detectPackage(dir);
+                        if (p && !packages.find(x => x.name === p.name))
+                            packages.push(p);
+                    }
+                }
+                return new Workspace(inf.root, packages, pkgJson.rman);
+            }
+            root = path.resolve(root, '..');
+        }
+        throw new Error('No project workspace detected');
+    }
+}
+async function detectPackage(dirname) {
+    const pkgJson = getPackageJson(dirname);
+    if (pkgJson && pkgJson.name) {
+        return new Package(dirname, pkgJson);
+    }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "rman",
+  "description": "Monorepo repository manager",
+  "version": "0.0.1",
+  "author": "Panates",
+  "license": "MIT",
+  "contributors": [
+    "Eray Hanoglu <e.hanoglu@panates.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/rman.git"
+  },
+  "keywords": [
+    "javascript",
+    "typescript",
+    "monorepo",
+    "repository",
+    "build",
+    "lerna"
+  ],
+  "bin": {
+    "rman": "bin/rman.js"
+  },
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^8.3.0",
+    "fast-glob": "^3.2.7",
+    "npm-run-path": "^4.0.1",
+    "@netlify/parse-npm-script": "^0.1.2",
+    "cli-progress": "^3.9.1"
+  },
+  "devDependencies": {
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.4.8",
+    "@types/cli-progress": "^3.9.2",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "@babel/eslint-parser": "^7.16.3",
+    "eslint": "^8.0.0",
+    "eslint-config-google": "^0.14.0",
+    "mocha": "^9.0.1",
+    "nyc": "^15.1.0",
+    "ts-cleanup": "^0.2.2",
+    "ts-loader": "^9.0.0",
+    "ts-node": "^10.0.0",
+    "tsconfig-paths": "^3.9.0",
+    "typescript": "^4.5.2"
+  },
+  "engines": {
+    "node": ">= 14.0"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "TS_NODE_PROJECT='./test/tsconfig.json' mocha -r ts-node/register --reporter spec test/**/*.spec.ts",
+    "cover": "nyc --reporter=cobertura --reporter html --reporter text npm run test",
+    "clean": "npm run clean:src && npm run clean:dist",
+    "clean:dist": "ts-cleanup -d dist --remove-dirs --all",
+    "clean:src": "ts-cleanup -s src --all | ts-cleanup -s test",
+    "prebuild": "npm run clean && npm run lint",
+    "build": "tsc -b tsconfig.build.json",
+    "compile": "tsc -b tsconfig.json",
+    "lint": "eslint src/** --no-error-on-unmatched-pattern",
+    "travis-cover": "nyc --reporter lcovonly npm run test"
+  },
+  "nyc": {
+    "temp-dir": "./coverage/.nyc_output"
+  }
+}