@oclif/core 3.0.4 → 3.0.5-dev.0

package/lib/config/plugin.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
+/* eslint-disable no-await-in-loop */
 const globby_1 = require("globby");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
@@ -33,45 +34,56 @@ function* up(from) {
     }
     yield from;
 }
-async function findSourcesRoot(root) {
+async function findSourcesRoot(root, name) {
+    // If we know the plugin name then we just need to traverse the file
+    // system until we find the directory that matches the plugin name.
+    if (name) {
+        for (const next of up(root)) {
+            if (next.endsWith((0, node_path_1.basename)(name)))
+                return next;
+        }
+    }
+    // If there's no plugin name (typically just the root plugin), then we need
+    // to traverse the file system until we find a directory with a package.json
     for (const next of up(root)) {
-        const cur = (0, node_path_1.join)(next, 'package.json');
-        // eslint-disable-next-line no-await-in-loop
-        if (await (0, fs_1.exists)(cur))
-            return (0, node_path_1.dirname)(cur);
+        // Skip the bin directory
+        if ((0, node_path_1.basename)((0, node_path_1.dirname)(next)) === 'bin' &&
+            ['dev', 'dev.cmd', 'dev.js', 'run', 'run.cmd', 'run.js'].includes((0, node_path_1.basename)(next))) {
+            continue;
+        }
+        try {
+            const cur = (0, node_path_1.join)(next, 'package.json');
+            if (await (0, fs_1.safeReadJson)(cur))
+                return (0, node_path_1.dirname)(cur);
+        }
+        catch { }
     }
 }
 /**
- * @returns string
- * @param name string
- * @param root string
- * find package root
- * for packages installed into node_modules this will go up directories until
- * it finds a node_modules directory with the plugin installed into it
+ * Find package root for packages installed into node_modules. This will go up directories
+ * until it finds a node_modules directory with the plugin installed into it
  *
  * This is needed because some oclif plugins do not declare the `main` field in their package.json
  * https://github.com/oclif/config/pull/289#issuecomment-983904051
+ *
+ * @returns string
+ * @param name string
+ * @param root string
  */
 async function findRootLegacy(name, root) {
     for (const next of up(root)) {
         let cur;
         if (name) {
             cur = (0, node_path_1.join)(next, 'node_modules', name, 'package.json');
-            // eslint-disable-next-line no-await-in-loop
-            if (await (0, fs_1.exists)(cur))
+            if (await (0, fs_1.safeReadJson)(cur))
                 return (0, node_path_1.dirname)(cur);
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                const pkg = await (0, fs_1.readJson)((0, node_path_1.join)(next, 'package.json'));
-                if (pkg.name === name)
-                    return next;
-            }
-            catch { }
+            const pkg = await (0, fs_1.safeReadJson)((0, node_path_1.join)(next, 'package.json'));
+            if (pkg?.name === name)
+                return next;
         }
         else {
             cur = (0, node_path_1.join)(next, 'package.json');
-            // eslint-disable-next-line no-await-in-loop
-            if (await (0, fs_1.exists)(cur))
+            if (await (0, fs_1.safeReadJson)(cur))
                 return (0, node_path_1.dirname)(cur);
         }
     }
@@ -83,7 +95,7 @@ async function findRoot(name, root) {
             pkgPath = (0, util_2.resolvePackage)(name, { paths: [root] });
         }
         catch { }
-        return pkgPath ? findSourcesRoot((0, node_path_1.dirname)(pkgPath)) : findRootLegacy(name, root);
+        return pkgPath ? findSourcesRoot((0, node_path_1.dirname)(pkgPath), name) : findRootLegacy(name, root);
     }
     return findSourcesRoot(root);
 }
@@ -97,11 +109,6 @@ const search = (cmd) => {
 };
 class Plugin {
     options;
-    _base = `${_pjson.name}@${_pjson.version}`;
-    _commandsDir;
-    // eslint-disable-next-line new-cap
-    _debug = (0, util_2.Debug)();
-    flexibleTaxonomy;
     alias;
     alreadyLoaded = false;
     children = [];
@@ -120,94 +127,40 @@ class Plugin {
     valid = false;
     version;
     warned = false;
+    _base = `${_pjson.name}@${_pjson.version}`;
+    _commandsDir;
+    // eslint-disable-next-line new-cap
+    _debug = (0, util_2.Debug)();
+    flexibleTaxonomy;
     constructor(options) {
         this.options = options;
     }
-    async _manifest() {
-        const ignoreManifest = Boolean(this.options.ignoreManifest);
-        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
-        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
-        const readManifest = async (dotfile = false) => {
-            try {
-                const p = (0, node_path_1.join)(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
-                const manifest = await (0, fs_1.readJson)(p);
-                if (!process.env.OCLIF_NEXT_VERSION && manifest.version.split('-')[0] !== this.version.split('-')[0]) {
-                    process.emitWarning(`Mismatched version in ${this.name} plugin manifest. Expected: ${this.version} Received: ${manifest.version}\nThis usually means you have an oclif.manifest.json file that should be deleted in development. This file should be automatically generated when publishing.`);
-                }
-                else {
-                    this._debug('using manifest from', p);
-                    this.hasManifest = true;
-                    return manifest;
-                }
-            }
-            catch (error) {
-                if (error.code === 'ENOENT') {
-                    if (!dotfile)
-                        return readManifest(true);
-                }
-                else {
-                    this.warn(error, 'readManifest');
-                }
-            }
-        };
-        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.manifest#${this.name}`, { plugin: this.name });
-        if (!ignoreManifest) {
-            const manifest = await readManifest();
-            if (manifest) {
-                marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: true });
-                marker?.stop();
-                return manifest;
-            }
-        }
-        const manifest = {
-            commands: (await Promise.all(this.commandIDs.map(async (id) => {
-                try {
-                    const cached = await (0, cache_command_1.cacheCommand)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
-                    if (this.flexibleTaxonomy) {
-                        const permutations = (0, util_2.getCommandIdPermutations)(id);
-                        const aliasPermutations = cached.aliases.flatMap((a) => (0, util_2.getCommandIdPermutations)(a));
-                        return [id, { ...cached, aliasPermutations, permutations }];
-                    }
-                    return [id, cached];
-                }
-                catch (error) {
-                    const scope = 'cacheCommand';
-                    if (Boolean(errorOnManifestCreate) === false)
-                        this.warn(error, scope);
-                    else
-                        throw this.addErrorScope(error, scope);
-                }
-            })))
-                // eslint-disable-next-line unicorn/no-await-expression-member, unicorn/prefer-native-coercion-functions
-                .filter((f) => Boolean(f))
-                .reduce((commands, [id, c]) => {
-                commands[id] = c;
-                return commands;
-            }, {}),
-            version: this.version,
-        };
-        marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: false });
+    get commandIDs() {
+        if (!this.commandsDir)
+            return [];
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.commandIDs#${this.name}`, { plugin: this.name });
+        this._debug(`loading IDs from ${this.commandsDir}`);
+        const patterns = ['**/*.+(js|cjs|mjs|ts|tsx)', '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js)?(x)'];
+        const ids = (0, globby_1.sync)(patterns, { cwd: this.commandsDir }).map((file) => {
+            const p = (0, node_path_1.parse)(file);
+            const topics = p.dir.split('/');
+            const command = p.name !== 'index' && p.name;
+            const id = [...topics, command].filter(Boolean).join(':');
+            return id === '' ? '.' : id;
+        });
+        this._debug('found commands', ids);
+        marker?.addDetails({ count: ids.length });
         marker?.stop();
-        return manifest;
+        return ids;
     }
-    addErrorScope(err, scope) {
-        err.name = `${err.name} Plugin: ${this.name}`;
-        err.detail = (0, util_1.compact)([
-            err.detail,
-            `module: ${this._base}`,
-            scope && `task: ${scope}`,
-            `plugin: ${this.name}`,
-            `root: ${this.root}`,
-            'See more details with DEBUG=*',
-        ]).join('\n');
-        return err;
+    get commandsDir() {
+        if (this._commandsDir)
+            return this._commandsDir;
+        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
+        return this._commandsDir;
     }
-    warn(err, scope) {
-        if (this.warned)
-            return;
-        if (typeof err === 'string')
-            err = new Error(err);
-        process.emitWarning(this.addErrorScope(err, scope));
+    get topics() {
+        return topicsToArray(this.pjson.oclif.topics || {});
     }
     async findCommand(id, opts = {}) {
         const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.findCommand#${this.name}.${id}`, {
@@ -291,32 +244,91 @@ class Plugin {
         }))
             .sort((a, b) => a.id.localeCompare(b.id));
     }
-    get commandIDs() {
-        if (!this.commandsDir)
-            return [];
-        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.commandIDs#${this.name}`, { plugin: this.name });
-        this._debug(`loading IDs from ${this.commandsDir}`);
-        const patterns = ['**/*.+(js|cjs|mjs|ts|tsx)', '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js)?(x)'];
-        const ids = (0, globby_1.sync)(patterns, { cwd: this.commandsDir }).map((file) => {
-            const p = (0, node_path_1.parse)(file);
-            const topics = p.dir.split('/');
-            const command = p.name !== 'index' && p.name;
-            const id = [...topics, command].filter(Boolean).join(':');
-            return id === '' ? '.' : id;
-        });
-        this._debug('found commands', ids);
-        marker?.addDetails({ count: ids.length });
+    async _manifest() {
+        const ignoreManifest = Boolean(this.options.ignoreManifest);
+        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
+        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
+        const readManifest = async (dotfile = false) => {
+            try {
+                const p = (0, node_path_1.join)(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
+                const manifest = await (0, fs_1.readJson)(p);
+                if (!process.env.OCLIF_NEXT_VERSION && manifest.version.split('-')[0] !== this.version.split('-')[0]) {
+                    process.emitWarning(`Mismatched version in ${this.name} plugin manifest. Expected: ${this.version} Received: ${manifest.version}\nThis usually means you have an oclif.manifest.json file that should be deleted in development. This file should be automatically generated when publishing.`);
+                }
+                else {
+                    this._debug('using manifest from', p);
+                    this.hasManifest = true;
+                    return manifest;
+                }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    if (!dotfile)
+                        return readManifest(true);
+                }
+                else {
+                    this.warn(error, 'readManifest');
+                }
+            }
+        };
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.manifest#${this.name}`, { plugin: this.name });
+        if (!ignoreManifest) {
+            const manifest = await readManifest();
+            if (manifest) {
+                marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: true });
+                marker?.stop();
+                return manifest;
+            }
+        }
+        const manifest = {
+            commands: (await Promise.all(this.commandIDs.map(async (id) => {
+                try {
+                    const cached = await (0, cache_command_1.cacheCommand)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
+                    if (this.flexibleTaxonomy) {
+                        const permutations = (0, util_2.getCommandIdPermutations)(id);
+                        const aliasPermutations = cached.aliases.flatMap((a) => (0, util_2.getCommandIdPermutations)(a));
+                        return [id, { ...cached, aliasPermutations, permutations }];
+                    }
+                    return [id, cached];
+                }
+                catch (error) {
+                    const scope = 'cacheCommand';
+                    if (Boolean(errorOnManifestCreate) === false)
+                        this.warn(error, scope);
+                    else
+                        throw this.addErrorScope(error, scope);
+                }
+            })))
+                // eslint-disable-next-line unicorn/no-await-expression-member, unicorn/prefer-native-coercion-functions
+                .filter((f) => Boolean(f))
+                .reduce((commands, [id, c]) => {
+                commands[id] = c;
+                return commands;
+            }, {}),
+            version: this.version,
+        };
+        marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: false });
         marker?.stop();
-        return ids;
+        return manifest;
     }
-    get commandsDir() {
-        if (this._commandsDir)
-            return this._commandsDir;
-        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
-        return this._commandsDir;
+    addErrorScope(err, scope) {
+        err.name = `${err.name} Plugin: ${this.name}`;
+        err.detail = (0, util_1.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            'See more details with DEBUG=*',
+        ]).join('\n');
+        return err;
     }
-    get topics() {
-        return topicsToArray(this.pjson.oclif.topics || {});
+    warn(err, scope) {
+        if (this.warned)
+            return;
+        if (typeof err === 'string')
+            err = new Error(err);
+        process.emitWarning(this.addErrorScope(err, scope));
     }
 }
 exports.Plugin = Plugin;

package/lib/errors/errors/cli.d.ts

@@ -12,13 +12,13 @@ export declare class CLIError extends Error implements OclifError {
     constructor(error: Error | string, options?: {
         exit?: false | number;
     } & PrettyPrintableError);
+    get bang(): string | undefined;
+    get stack(): string;
     /**
      * @deprecated `render` Errors display should be handled by display function, like pretty-print
      * @return {string} returns a string representing the dispay of the error
      */
     render(): string;
-    get bang(): string | undefined;
-    get stack(): string;
 }
 export declare namespace CLIError {
     class Warn extends CLIError {

package/lib/errors/errors/cli.js

@@ -30,6 +30,15 @@ class CLIError extends Error {
         this.code = options.code;
         this.suggestions = options.suggestions;
     }
+    get bang() {
+        try {
+            return chalk_1.default.red(process.platform === 'win32' ? '»' : '›');
+        }
+        catch { }
+    }
+    get stack() {
+        return (0, clean_stack_1.default)(super.stack, { pretty: true });
+    }
     /**
      * @deprecated `render` Errors display should be handled by display function, like pretty-print
      * @return {string} returns a string representing the dispay of the error
@@ -45,15 +54,6 @@ class CLIError extends Error {
         output = (0, indent_string_1.default)(output, 1);
         return output;
     }
-    get bang() {
-        try {
-            return chalk_1.default.red(process.platform === 'win32' ? '»' : '›');
-        }
-        catch { }
-    }
-    get stack() {
-        return (0, clean_stack_1.default)(super.stack, { pretty: true });
-    }
 }
 exports.CLIError = CLIError;
 (function (CLIError) {

package/lib/help/command.d.ts

@@ -6,8 +6,6 @@ export declare class CommandHelp extends HelpFormatter {
     config: Interfaces.Config;
     opts: Interfaces.HelpOptions;
     constructor(command: Command.Loadable, config: Interfaces.Config, opts: Interfaces.HelpOptions);
-    private formatIfCommand;
-    private isCommand;
     protected aliases(aliases: string[] | undefined): string | undefined;
     protected arg(arg: Command.Arg.Any): string;
     protected args(args: Command.Arg.Any[]): [string, string | undefined][] | undefined;
@@ -29,5 +27,7 @@ export declare class CommandHelp extends HelpFormatter {
         header: string;
     }>;
     protected usage(): string;
+    private formatIfCommand;
+    private isCommand;
 }
 export default CommandHelp;

package/lib/help/command.js

@@ -27,17 +27,6 @@ class CommandHelp extends formatter_1.HelpFormatter {
         this.config = config;
         this.opts = opts;
     }
-    formatIfCommand(example) {
-        example = this.render(example);
-        if (example.startsWith(this.config.bin))
-            return dim(`$ ${example}`);
-        if (example.startsWith(`$ ${this.config.bin}`))
-            return dim(example);
-        return example;
-    }
-    isCommand(example) {
-        return (0, strip_ansi_1.default)(this.formatIfCommand(example)).startsWith(`$ ${this.config.bin}`);
-    }
     aliases(aliases) {
         if (!aliases || aliases.length === 0)
             return;
@@ -295,6 +284,17 @@ class CommandHelp extends formatter_1.HelpFormatter {
             .join('\n');
         return body;
     }
+    formatIfCommand(example) {
+        example = this.render(example);
+        if (example.startsWith(this.config.bin))
+            return dim(`$ ${example}`);
+        if (example.startsWith(`$ ${this.config.bin}`))
+            return dim(example);
+        return example;
+    }
+    isCommand(example) {
+        return (0, strip_ansi_1.default)(this.formatIfCommand(example)).startsWith(`$ ${this.config.bin}`);
+    }
 }
 exports.CommandHelp = CommandHelp;
 exports.default = CommandHelp;

package/lib/help/docopts.d.ts

@@ -61,8 +61,8 @@ export declare class DocOpts {
     private flagMap;
     constructor(cmd: Command.Cached | Command.Class | Command.Loadable);
     static generate(cmd: Command.Cached | Command.Class | Command.Loadable): string;
+    toString(): string;
     private combineElementsToFlag;
     private generateElements;
     private groupFlagElements;
-    toString(): string;
 }

package/lib/help/docopts.js

@@ -76,6 +76,26 @@ class DocOpts {
     static generate(cmd) {
         return new DocOpts(cmd).toString();
     }
+    toString() {
+        const opts = this.cmd.id === '.' || this.cmd.id === '' ? [] : ['<%= command.id %>'];
+        if (this.cmd.args) {
+            const a = Object.values((0, ensure_arg_object_1.ensureArgObject)(this.cmd.args)).map((arg) => arg.required ? arg.name.toUpperCase() : `[${arg.name.toUpperCase()}]`) || [];
+            opts.push(...a);
+        }
+        try {
+            opts.push(...Object.values(this.groupFlagElements()));
+        }
+        catch {
+            // If there is an error, just return no usage so we don't fail command help.
+            opts.push(...this.flagList.map((flag) => {
+                const name = flag.char ? `-${flag.char}` : `--${flag.name}`;
+                if (flag.type === 'boolean')
+                    return name;
+                return `${name}=<value>`;
+            }));
+        }
+        return opts.join(' ');
+    }
     combineElementsToFlag(elementMap, flagName, flagNames, unionString) {
         if (!this.flagMap[flagName]) {
             return;
@@ -134,25 +154,5 @@ class DocOpts {
         }
         return elementMap;
     }
-    toString() {
-        const opts = this.cmd.id === '.' || this.cmd.id === '' ? [] : ['<%= command.id %>'];
-        if (this.cmd.args) {
-            const a = Object.values((0, ensure_arg_object_1.ensureArgObject)(this.cmd.args)).map((arg) => arg.required ? arg.name.toUpperCase() : `[${arg.name.toUpperCase()}]`) || [];
-            opts.push(...a);
-        }
-        try {
-            opts.push(...Object.values(this.groupFlagElements()));
-        }
-        catch {
-            // If there is an error, just return no usage so we don't fail command help.
-            opts.push(...this.flagList.map((flag) => {
-                const name = flag.char ? `-${flag.char}` : `--${flag.name}`;
-                if (flag.type === 'boolean')
-                    return name;
-                return `${name}=<value>`;
-            }));
-        }
-        return opts.join(' ');
-    }
 }
 exports.DocOpts = DocOpts;

package/lib/help/index.d.ts

@@ -21,7 +21,8 @@ export declare abstract class HelpBase extends HelpFormatter {
 export declare class Help extends HelpBase {
     protected CommandHelpClass: typeof CommandHelp;
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
-    private get _topics();
+    protected get sortedCommands(): Command.Loadable[];
+    protected get sortedTopics(): Interfaces.Topic[];
     protected command(command: Command.Loadable): string;
     protected description(c: Command.Loadable): string;
     protected formatCommand(command: Command.Loadable): string;
@@ -36,8 +37,7 @@ export declare class Help extends HelpBase {
     protected showRootHelp(): Promise<void>;
     protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
     protected summary(c: Command.Loadable): string | undefined;
-    protected get sortedCommands(): Command.Loadable[];
-    protected get sortedTopics(): Interfaces.Topic[];
+    private get _topics();
 }
 interface HelpBaseDerived {
     new (config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>): HelpBase;

package/lib/help/index.js

@@ -45,18 +45,19 @@ class Help extends HelpBase {
     constructor(config, opts = {}) {
         super(config, opts);
     }
-    /*
-     * _topics is to work around Interfaces.topics mistakenly including commands that do
-     * not have children, as well as topics. A topic has children, either commands or other topics. When
-     * this is fixed upstream config.topics should return *only* topics with children,
-     * and this can be removed.
-     */
-    get _topics() {
-        return this.config.topics.filter((topic) => {
-            // it is assumed a topic has a child if it has children
-            const hasChild = this.config.topics.some((subTopic) => subTopic.name.includes(`${topic.name}:`));
-            return hasChild;
-        });
+    get sortedCommands() {
+        let { commands } = this.config;
+        commands = commands.filter((c) => this.opts.all || !c.hidden);
+        commands = (0, util_1.sortBy)(commands, (c) => c.id);
+        commands = (0, util_1.uniqBy)(commands, (c) => c.id);
+        return commands;
+    }
+    get sortedTopics() {
+        let topics = this._topics;
+        topics = topics.filter((t) => this.opts.all || !t.hidden);
+        topics = (0, util_1.sortBy)(topics, (t) => t.name);
+        topics = (0, util_1.uniqBy)(topics, (t) => t.name);
+        return topics;
     }
     command(command) {
         return this.formatCommand(command);
@@ -266,19 +267,18 @@ class Help extends HelpBase {
             return this.render(c.summary.split('\n')[0]);
         return c.description && this.render(c.description).split('\n')[0];
     }
-    get sortedCommands() {
-        let { commands } = this.config;
-        commands = commands.filter((c) => this.opts.all || !c.hidden);
-        commands = (0, util_1.sortBy)(commands, (c) => c.id);
-        commands = (0, util_1.uniqBy)(commands, (c) => c.id);
-        return commands;
-    }
-    get sortedTopics() {
-        let topics = this._topics;
-        topics = topics.filter((t) => this.opts.all || !t.hidden);
-        topics = (0, util_1.sortBy)(topics, (t) => t.name);
-        topics = (0, util_1.uniqBy)(topics, (t) => t.name);
-        return topics;
+    /*
+     * _topics is to work around Interfaces.topics mistakenly including commands that do
+     * not have children, as well as topics. A topic has children, either commands or other topics. When
+     * this is fixed upstream config.topics should return *only* topics with children,
+     * and this can be removed.
+     */
+    get _topics() {
+        return this.config.topics.filter((topic) => {
+            // it is assumed a topic has a child if it has children
+            const hasChild = this.config.topics.some((subTopic) => subTopic.name.includes(`${topic.name}:`));
+            return hasChild;
+        });
     }
 }
 exports.Help = Help;

package/lib/parser/parse.d.ts

@@ -8,8 +8,9 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     private readonly flagAliases;
     private readonly raw;
     constructor(input: T);
-    private get _argTokens();
+    parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
     private _args;
+    private get _argTokens();
     private _debugInput;
     private _debugOutput;
     private _flags;
@@ -18,5 +19,4 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     private findLongFlag;
     private findShortFlag;
     private mapAndValidateFlags;
-    parse(): Promise<ParserOutput<TFlags, BFlags, TArgs>>;
 }