knip 0.0.0-angular.0

package/dist/typescript/visitors/imports/importDeclaration.js

@@ -0,0 +1,32 @@
+import ts from 'typescript';
+import { isDefaultImport } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, (node, options) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
+        const specifier = node.moduleSpecifier.text;
+        if (!node.importClause) {
+            return { specifier };
+        }
+        else {
+            if (node.importClause.isTypeOnly && options.skipTypeOnly)
+                return;
+            const imports = [];
+            if (isDefaultImport(node)) {
+                imports.push({ specifier, identifier: 'default' });
+            }
+            if (node.importClause?.namedBindings) {
+                if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                    const symbol = node.importClause.namedBindings.symbol;
+                    imports.push({ symbol, specifier, identifier: '*' });
+                }
+                if (ts.isNamedImports(node.importClause.namedBindings)) {
+                    node.importClause.namedBindings.elements.forEach(element => {
+                        const identifier = (element.propertyName ?? element.name).getText();
+                        imports.push({ symbol: element.symbol, specifier, identifier });
+                    });
+                }
+            }
+            return imports;
+        }
+    }
+});

package/dist/typescript/visitors/imports/importEqualsDeclaration.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/imports/importEqualsDeclaration.js

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import { isNotJS } from '../helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(isNotJS, node => {
+    if (ts.isImportEqualsDeclaration(node) &&
+        ts.isExternalModuleReference(node.moduleReference) &&
+        ts.isStringLiteralLike(node.moduleReference.expression)) {
+        const specifier = node.moduleReference.expression.text;
+        return { specifier, identifier: 'default' };
+    }
+});

package/dist/typescript/visitors/imports/index.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => (((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined)[];
+export default _default;

package/dist/typescript/visitors/imports/index.js

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import importCall from './importCall.js';
+import importDeclaration from './importDeclaration.js';
+import importEqualsDeclaration from './importEqualsDeclaration.js';
+import jsDocType from './jsDocType.js';
+import reExportDeclaration from './reExportDeclaration.js';
+import requireCall from './requireCall.js';
+import requireResolveCall from './requireResolveCall.js';
+const visitors = [
+    importCall,
+    importDeclaration,
+    importEqualsDeclaration,
+    jsDocType,
+    reExportDeclaration,
+    requireCall,
+    requireResolveCall,
+];
+export default (sourceFile) => visitors.map(v => v(sourceFile));

package/dist/typescript/visitors/imports/jsDocType.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/imports/jsDocType.js

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import { isValidImportTypeNode } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if ('jsDoc' in node) {
+        const type = ts.getJSDocType(node);
+        if (type && isValidImportTypeNode(type)) {
+            return { specifier: type.argument.literal.text };
+        }
+    }
+});

package/dist/typescript/visitors/imports/reExportDeclaration.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/imports/reExportDeclaration.js

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (ts.isExportDeclaration(node)) {
+        if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+            if (!node.exportClause) {
+                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true };
+            }
+            else if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
+                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true };
+            }
+            else {
+                const specifier = node.moduleSpecifier;
+                return node.exportClause.elements.map(element => {
+                    const identifier = (element.propertyName ?? element.name).getText();
+                    return { identifier, specifier: specifier.text, isReExport: true };
+                });
+            }
+        }
+    }
+});

package/dist/typescript/visitors/imports/requireCall.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/imports/requireCall.js

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { isRequireCall, findAncestor, findDescendants } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (isRequireCall(node)) {
+        if (ts.isStringLiteralLike(node.arguments[0])) {
+            const specifier = node.arguments[0].text;
+            if (specifier) {
+                const propertyAccessExpression = findAncestor(node, _node => {
+                    if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
+                        return 'STOP';
+                    return ts.isPropertyAccessExpression(_node);
+                });
+                if (propertyAccessExpression) {
+                    const identifier = String(propertyAccessExpression.name.escapedText);
+                    return { identifier, specifier };
+                }
+                else {
+                    const variableDeclaration = node.parent;
+                    if (ts.isVariableDeclaration(variableDeclaration) &&
+                        ts.isVariableDeclarationList(variableDeclaration.parent)) {
+                        if (ts.isIdentifier(variableDeclaration.name)) {
+                            return { identifier: 'default', specifier };
+                        }
+                        else {
+                            const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
+                            if (bindings.length > 0) {
+                                return bindings.map(element => {
+                                    const identifier = (element.propertyName ?? element.name).getText();
+                                    return { identifier, specifier };
+                                });
+                            }
+                            else {
+                                return { identifier: 'default', specifier };
+                            }
+                        }
+                    }
+                    else {
+                        return { identifier: 'default', specifier };
+                    }
+                }
+            }
+        }
+    }
+});

package/dist/typescript/visitors/imports/requireResolveCall.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => import("../../getImportsAndExports.js").AddImportOptions | import("../../getImportsAndExports.js").AddImportOptions[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/imports/requireResolveCall.js

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+import { isRequireResolveCall } from '../../ast-helpers.js';
+import { importVisitor as visit } from '../index.js';
+export default visit(() => true, node => {
+    if (isRequireResolveCall(node)) {
+        if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
+            const specifier = node.arguments[0].text;
+            if (specifier)
+                return { specifier };
+        }
+    }
+});

package/dist/typescript/visitors/index.d.ts

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+import type { GetImportsAndExportsOptions, AddExportOptions, AddImportOptions } from '../getImportsAndExports.js';
+type FileCondition = (sourceFile: ts.SourceFile) => boolean;
+type VisitorFactory<T> = (fileCondition: FileCondition, fn: Visitor<T>) => VisitorCondition<T>;
+type VisitorCondition<T> = (sourceFile: ts.SourceFile) => undefined | Visitor<T>;
+type Visitor<T> = (node: ts.Node, options: GetImportsAndExportsOptions) => undefined | T | T[];
+export declare const importVisitor: VisitorFactory<AddImportOptions>;
+export declare const exportVisitor: VisitorFactory<AddExportOptions>;
+export declare const scriptVisitor: VisitorFactory<string>;
+export {};

package/dist/typescript/visitors/index.js

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+export const importVisitor = (fileCondition, visitorFn) => sourceFile => {
+    if (fileCondition(sourceFile)) {
+        return (node, options) => visitorFn(node, options);
+    }
+};
+export const exportVisitor = (fileCondition, visitorFn) => sourceFile => {
+    if (fileCondition(sourceFile)) {
+        return (node, options) => visitorFn(node, options);
+    }
+};
+export const scriptVisitor = (fileCondition, visitorFn) => sourceFile => {
+    if (fileCondition(sourceFile)) {
+        return (node, options) => visitorFn(node, options);
+    }
+};

package/dist/typescript/visitors/scripts/execa.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => string | string[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/scripts/execa.js

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import { stripQuotes } from '../../ast-helpers.js';
+import { scriptVisitor as visit } from '../index.js';
+export default visit(sourceFile => sourceFile.statements.some(statementImportsExeca$), node => {
+    if (ts.isTaggedTemplateExpression(node)) {
+        if (node.tag.getText() === '$' || (ts.isCallExpression(node.tag) && node.tag.expression.getText() === '$')) {
+            return stripQuotes(node.template.getText());
+        }
+    }
+});
+function statementImportsExeca$(node) {
+    return (ts.isImportDeclaration(node) &&
+        ts.isStringLiteral(node.moduleSpecifier) &&
+        node.moduleSpecifier.text === 'execa' &&
+        !!node.importClause?.namedBindings &&
+        ts.isNamedImports(node.importClause.namedBindings) &&
+        node.importClause.namedBindings.elements.some(element => element.name.text === '$'));
+}

package/dist/typescript/visitors/scripts/index.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => (((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => string | string[] | undefined) | undefined)[];
+export default _default;

package/dist/typescript/visitors/scripts/index.js

@@ -0,0 +1,5 @@
+import ts from 'typescript';
+import execa from './execa.js';
+import zx from './zx.js';
+const visitors = [execa, zx];
+export default (sourceFile) => visitors.map(v => v(sourceFile));

package/dist/typescript/visitors/scripts/zx.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => string | string[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/scripts/zx.js

@@ -0,0 +1,8 @@
+import ts from 'typescript';
+import { stripQuotes } from '../../ast-helpers.js';
+import { scriptVisitor as visit } from '../index.js';
+export default visit(sourceFile => ts.getShebang(sourceFile.text) === '#!/usr/bin/env zx', node => {
+    if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {
+        return stripQuotes(node.template.getText());
+    }
+});

package/dist/util/Performance.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import { PerformanceObserver, PerformanceEntry } from 'node:perf_hooks';
+import type { TimerifyOptions } from 'node:perf_hooks';
+type Timerify = <T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions) => T;
+export declare const timerify: Timerify;
+export declare class Performance {
+    isEnabled: boolean;
+    startTime: number;
+    endTime: number;
+    entries: PerformanceEntry[];
+    instanceId?: number;
+    observer?: PerformanceObserver;
+    constructor(isEnabled: boolean);
+    private setMark;
+    private clearMark;
+    private flush;
+    private getEntriesByName;
+    getTable(): string;
+    getTotalTime(): number;
+    finalize(): Promise<void>;
+    reset(): void;
+}
+export {};

package/dist/util/Performance.js

@@ -0,0 +1,80 @@
+import { performance, PerformanceObserver, PerformanceEntry } from 'node:perf_hooks';
+import EasyTable from 'easy-table';
+import Summary from 'summary';
+import parsedArgValues from './cli-arguments.js';
+const { performance: isEnabled = false } = parsedArgValues;
+export const timerify = fn => (isEnabled ? performance.timerify(fn) : fn);
+export class Performance {
+    isEnabled;
+    startTime = 0;
+    endTime = 0;
+    entries = [];
+    instanceId;
+    observer;
+    constructor(isEnabled) {
+        if (isEnabled) {
+            this.startTime = performance.now();
+            this.instanceId = Math.floor(performance.now() * 100);
+            this.observer = new PerformanceObserver(items => {
+                items.getEntries().forEach(entry => {
+                    this.entries.push(entry);
+                });
+            });
+            this.observer.observe({ entryTypes: ['function'] });
+        }
+        this.isEnabled = isEnabled;
+    }
+    setMark(name) {
+        const id = `${this.instanceId}:${name}`;
+        performance.mark(`${id}:start`);
+    }
+    clearMark(name) {
+        const id = `${this.instanceId}:${name}`;
+        performance.mark(`${id}:end`);
+        performance.measure(id, `${id}:start`, `${id}:end`);
+        performance.clearMarks(`${id}:start`);
+        performance.clearMarks(`${id}:end`);
+    }
+    async flush() {
+        this.setMark('_flush');
+        await new Promise(resolve => setTimeout(resolve, 1));
+        this.clearMark('_flush');
+    }
+    getEntriesByName() {
+        return this.entries.reduce((entries, entry) => {
+            const name = entry.name.replace(`${this.instanceId}:`, '');
+            entries[name] = entries[name] ?? [];
+            entries[name].push(entry.duration);
+            return entries;
+        }, {});
+    }
+    getTable() {
+        const entriesByName = this.getEntriesByName();
+        const table = new EasyTable();
+        Object.entries(entriesByName).map(([name, values]) => {
+            const stats = new Summary(values);
+            table.cell('Name', name);
+            table.cell('size', stats.size(), EasyTable.number(0));
+            table.cell('min', stats.min(), EasyTable.number(2));
+            table.cell('max', stats.max(), EasyTable.number(2));
+            table.cell('median', stats.median(), EasyTable.number(2));
+            table.cell('sum', stats.sum(), EasyTable.number(2));
+            table.newRow();
+        });
+        table.sort(['sum|des']);
+        return table.toString().trim();
+    }
+    getTotalTime() {
+        return this.endTime - this.startTime;
+    }
+    async finalize() {
+        if (!this.isEnabled)
+            return;
+        this.endTime = performance.now();
+        await this.flush();
+    }
+    reset() {
+        this.entries = [];
+        this.observer?.disconnect();
+    }
+}

package/dist/util/array.d.ts

@@ -0,0 +1,2 @@
+export declare const compact: <T>(collection: (T | undefined)[]) => T[];
+export declare const arrayify: (value?: string[] | string) => string[];

package/dist/util/array.js

@@ -0,0 +1,2 @@
+export const compact = (collection) => Array.from(new Set(collection)).filter((value) => Boolean(value));
+export const arrayify = (value) => Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];

package/dist/util/cli-arguments.d.ts

@@ -0,0 +1,28 @@
+export declare const helpText = "\u2702\uFE0F  Find unused files, dependencies and exports in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.js, knip.ts or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  --ignore-internal        Ignore exports with tag @internal (JSDoc/TSDoc)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,unresolved\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --include-entry-exports  Include entry files when reporting unused exports\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --no-config-hints        Suppress configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of issues before non-zero exit code (default: 0)\n  -d, --debug              Show debug output\n  --debug-file-filter      Filter for files in debug output (regex as string)\n  --performance            Measure count and running time of expensive functions and display stats table\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n$ knip --debug --debug-file-filter '(specific|particular)-module'\n\nMore documentation and bug reports: https://github.com/webpro/knip";
+declare const _default: {
+    config: string | undefined;
+    debug: boolean | undefined;
+    'debug-file-filter': string | undefined;
+    dependencies: boolean | undefined;
+    exclude: string[] | undefined;
+    exports: boolean | undefined;
+    help: boolean | undefined;
+    'ignore-internal': boolean | undefined;
+    include: string[] | undefined;
+    'include-entry-exports': boolean | undefined;
+    'max-issues': string | undefined;
+    'no-config-hints': boolean | undefined;
+    'no-exit-code': boolean | undefined;
+    'no-gitignore': boolean | undefined;
+    'no-progress': boolean | undefined;
+    performance: boolean | undefined;
+    production: boolean | undefined;
+    preprocessor: string[] | undefined;
+    reporter: string[] | undefined;
+    'reporter-options': string | undefined;
+    strict: boolean | undefined;
+    tsConfig: string | undefined;
+    version: boolean | undefined;
+    workspace: string | undefined;
+};
+export default _default;

package/dist/util/cli-arguments.js

@@ -0,0 +1,83 @@
+import { parseArgs } from 'node:util';
+export const helpText = `✂️  Find unused files, dependencies and exports in your JavaScript and TypeScript projects
+
+Usage: knip [options]
+
+Options:
+  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.js, knip.ts or package.json#knip)
+  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)
+  --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)
+  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)
+  --ignore-internal        Ignore exports with tag @internal (JSDoc/TSDoc)
+  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)
+  --no-gitignore           Don't use .gitignore
+  --include                Report only provided issue type(s), can be comma-separated or repeated (1)
+  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)
+  --dependencies           Shortcut for --include dependencies,unlisted,unresolved
+  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates
+  --include-entry-exports  Include entry files when reporting unused exports
+  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)
+  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated
+  --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)
+  --reporter-options       Pass extra options to the reporter (as JSON string, see example)
+  --no-config-hints        Suppress configuration hints
+  --no-exit-code           Always exit with code zero (0)
+  --max-issues             Maximum number of issues before non-zero exit code (default: 0)
+  -d, --debug              Show debug output
+  --debug-file-filter      Filter for files in debug output (regex as string)
+  --performance            Measure count and running time of expensive functions and display stats table
+  -h, --help               Print this help text
+  -V, --version            Print version
+
+(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates
+
+Examples:
+
+$ knip
+$ knip --production
+$ knip --workspace packages/client --include files,dependencies
+$ knip -c ./config/knip.json --reporter compact
+$ knip --reporter codeowners --reporter-options '{"path":".github/CODEOWNERS"}'
+$ knip --debug --debug-file-filter '(specific|particular)-module'
+
+More documentation and bug reports: https://github.com/webpro/knip`;
+let parsedArgs;
+try {
+    parsedArgs = parseArgs({
+        options: {
+            config: { type: 'string', short: 'c' },
+            debug: { type: 'boolean', short: 'd' },
+            'debug-file-filter': { type: 'string' },
+            dependencies: { type: 'boolean' },
+            exclude: { type: 'string', multiple: true },
+            exports: { type: 'boolean' },
+            help: { type: 'boolean', short: 'h' },
+            'ignore-internal': { type: 'boolean' },
+            include: { type: 'string', multiple: true },
+            'include-entry-exports': { type: 'boolean' },
+            'max-issues': { type: 'string' },
+            'no-config-hints': { type: 'boolean' },
+            'no-exit-code': { type: 'boolean' },
+            'no-gitignore': { type: 'boolean' },
+            'no-progress': { type: 'boolean', short: 'n' },
+            performance: { type: 'boolean' },
+            production: { type: 'boolean' },
+            preprocessor: { type: 'string', multiple: true },
+            reporter: { type: 'string', multiple: true },
+            'reporter-options': { type: 'string' },
+            strict: { type: 'boolean' },
+            tsConfig: { type: 'string', short: 't' },
+            version: { type: 'boolean', short: 'V' },
+            workspace: { type: 'string', short: 'W' },
+        },
+    });
+}
+catch (error) {
+    if (error instanceof Error) {
+        console.error(error.message);
+        console.log('\n' + helpText);
+        process.exit(1);
+    }
+    throw error;
+}
+export default parsedArgs.values;