@pnpm/exe 12.8.1 → 12.9.0

package/dist/wasm/node_modules/clipanion/lib/core.mjs

@@ -0,0 +1,800 @@
+import { BATCH_REGEX, BINDING_REGEX, OPTION_REGEX, HELP_REGEX, NODE_SUCCESS, NODE_ERRORED, END_OF_INPUT, HELP_COMMAND_INDEX, NODE_INITIAL, START_OF_INPUT, DEBUG } from './constants.mjs';
+import { UnknownSyntaxError, AmbiguousSyntaxError } from './errors.mjs';
+
+// ------------------------------------------------------------------------
+function debug(str) {
+    if (DEBUG) {
+        console.log(str);
+    }
+}
+const basicHelpState = {
+    candidateUsage: null,
+    requiredOptions: [],
+    errorMessage: null,
+    ignoreOptions: false,
+    path: [],
+    positionals: [],
+    options: [],
+    remainder: null,
+    selectedIndex: HELP_COMMAND_INDEX,
+};
+function makeStateMachine() {
+    return {
+        nodes: [makeNode(), makeNode(), makeNode()],
+    };
+}
+function makeAnyOfMachine(inputs) {
+    const output = makeStateMachine();
+    const heads = [];
+    let offset = output.nodes.length;
+    for (const input of inputs) {
+        heads.push(offset);
+        for (let t = 0; t < input.nodes.length; ++t)
+            if (!isTerminalNode(t))
+                output.nodes.push(cloneNode(input.nodes[t], offset));
+        offset += input.nodes.length - 2;
+    }
+    for (const head of heads)
+        registerShortcut(output, NODE_INITIAL, head);
+    return output;
+}
+function injectNode(machine, node) {
+    machine.nodes.push(node);
+    return machine.nodes.length - 1;
+}
+function simplifyMachine(input) {
+    const visited = new Set();
+    const process = (node) => {
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        const nodeDef = input.nodes[node];
+        for (const transitions of Object.values(nodeDef.statics))
+            for (const { to } of transitions)
+                process(to);
+        for (const [, { to }] of nodeDef.dynamics)
+            process(to);
+        for (const { to } of nodeDef.shortcuts)
+            process(to);
+        const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
+        while (nodeDef.shortcuts.length > 0) {
+            const { to } = nodeDef.shortcuts.shift();
+            const toDef = input.nodes[to];
+            for (const [segment, transitions] of Object.entries(toDef.statics)) {
+                const store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment)
+                    ? nodeDef.statics[segment] = []
+                    : nodeDef.statics[segment];
+                for (const transition of transitions) {
+                    if (!store.some(({ to }) => transition.to === to)) {
+                        store.push(transition);
+                    }
+                }
+            }
+            for (const [test, transition] of toDef.dynamics)
+                if (!nodeDef.dynamics.some(([otherTest, { to }]) => test === otherTest && transition.to === to))
+                    nodeDef.dynamics.push([test, transition]);
+            for (const transition of toDef.shortcuts) {
+                if (!shortcuts.has(transition.to)) {
+                    nodeDef.shortcuts.push(transition);
+                    shortcuts.add(transition.to);
+                }
+            }
+        }
+    };
+    process(NODE_INITIAL);
+}
+function debugMachine(machine, { prefix = `` } = {}) {
+    // Don't iterate unless it's needed
+    if (DEBUG) {
+        debug(`${prefix}Nodes are:`);
+        for (let t = 0; t < machine.nodes.length; ++t) {
+            debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
+        }
+    }
+}
+function runMachineInternal(machine, input, partial = false) {
+    debug(`Running a vm on ${JSON.stringify(input)}`);
+    let branches = [{ node: NODE_INITIAL, state: {
+                candidateUsage: null,
+                requiredOptions: [],
+                errorMessage: null,
+                ignoreOptions: false,
+                options: [],
+                path: [],
+                positionals: [],
+                remainder: null,
+                selectedIndex: null,
+            } }];
+    debugMachine(machine, { prefix: `  ` });
+    const tokens = [START_OF_INPUT, ...input];
+    for (let t = 0; t < tokens.length; ++t) {
+        const segment = tokens[t];
+        debug(`  Processing ${JSON.stringify(segment)}`);
+        const nextBranches = [];
+        for (const { node, state } of branches) {
+            debug(`    Current node is ${node}`);
+            const nodeDef = machine.nodes[node];
+            if (node === NODE_ERRORED) {
+                nextBranches.push({ node, state });
+                continue;
+            }
+            console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
+            const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
+            if (!partial || t < tokens.length - 1 || hasExactMatch) {
+                if (hasExactMatch) {
+                    const transitions = nodeDef.statics[segment];
+                    for (const { to, reducer } of transitions) {
+                        nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                        debug(`      Static transition to ${to} found`);
+                    }
+                }
+                else {
+                    debug(`      No static transition found`);
+                }
+            }
+            else {
+                let hasMatches = false;
+                for (const candidate of Object.keys(nodeDef.statics)) {
+                    if (!candidate.startsWith(segment))
+                        continue;
+                    if (segment === candidate) {
+                        for (const { to, reducer } of nodeDef.statics[candidate]) {
+                            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                            debug(`      Static transition to ${to} found`);
+                        }
+                    }
+                    else {
+                        for (const { to } of nodeDef.statics[candidate]) {
+                            nextBranches.push({ node: to, state: { ...state, remainder: candidate.slice(segment.length) } });
+                            debug(`      Static transition to ${to} found (partial match)`);
+                        }
+                    }
+                    hasMatches = true;
+                }
+                if (!hasMatches) {
+                    debug(`      No partial static transition found`);
+                }
+            }
+            if (segment !== END_OF_INPUT) {
+                for (const [test, { to, reducer }] of nodeDef.dynamics) {
+                    if (execute(tests, test, state, segment)) {
+                        nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                        debug(`      Dynamic transition to ${to} found (via ${test})`);
+                    }
+                }
+            }
+        }
+        if (nextBranches.length === 0 && segment === END_OF_INPUT && input.length === 1) {
+            return [{
+                    node: NODE_INITIAL,
+                    state: basicHelpState,
+                }];
+        }
+        if (nextBranches.length === 0) {
+            throw new UnknownSyntaxError(input, branches.filter(({ node }) => {
+                return node !== NODE_ERRORED;
+            }).map(({ state }) => {
+                return { usage: state.candidateUsage, reason: null };
+            }));
+        }
+        if (nextBranches.every(({ node }) => node === NODE_ERRORED)) {
+            throw new UnknownSyntaxError(input, nextBranches.map(({ state }) => {
+                return { usage: state.candidateUsage, reason: state.errorMessage };
+            }));
+        }
+        branches = trimSmallerBranches(nextBranches);
+    }
+    if (branches.length > 0) {
+        debug(`  Results:`);
+        for (const branch of branches) {
+            debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
+        }
+    }
+    else {
+        debug(`  No results`);
+    }
+    return branches;
+}
+function checkIfNodeIsFinished(node, state) {
+    if (state.selectedIndex !== null)
+        return true;
+    if (Object.prototype.hasOwnProperty.call(node.statics, END_OF_INPUT))
+        for (const { to } of node.statics[END_OF_INPUT])
+            if (to === NODE_SUCCESS)
+                return true;
+    return false;
+}
+function suggestMachine(machine, input, partial) {
+    // If we're accepting partial matches, then exact matches need to be
+    // prefixed with an extra space.
+    const prefix = partial && input.length > 0 ? [``] : [];
+    const branches = runMachineInternal(machine, input, partial);
+    const suggestions = [];
+    const suggestionsJson = new Set();
+    const traverseSuggestion = (suggestion, node, skipFirst = true) => {
+        let nextNodes = [node];
+        while (nextNodes.length > 0) {
+            const currentNodes = nextNodes;
+            nextNodes = [];
+            for (const node of currentNodes) {
+                const nodeDef = machine.nodes[node];
+                const keys = Object.keys(nodeDef.statics);
+                // The fact that `key` is unused is likely a bug, but no one has investigated it yet.
+                // TODO: Investigate it.
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                for (const key of Object.keys(nodeDef.statics)) {
+                    const segment = keys[0];
+                    for (const { to, reducer } of nodeDef.statics[segment]) {
+                        if (reducer !== `pushPath`)
+                            continue;
+                        if (!skipFirst)
+                            suggestion.push(segment);
+                        nextNodes.push(to);
+                    }
+                }
+            }
+            skipFirst = false;
+        }
+        const json = JSON.stringify(suggestion);
+        if (suggestionsJson.has(json))
+            return;
+        suggestions.push(suggestion);
+        suggestionsJson.add(json);
+    };
+    for (const { node, state } of branches) {
+        if (state.remainder !== null) {
+            traverseSuggestion([state.remainder], node);
+            continue;
+        }
+        const nodeDef = machine.nodes[node];
+        const isFinished = checkIfNodeIsFinished(nodeDef, state);
+        for (const [candidate, transitions] of Object.entries(nodeDef.statics))
+            if ((isFinished && candidate !== END_OF_INPUT) || (!candidate.startsWith(`-`) && transitions.some(({ reducer }) => reducer === `pushPath`)))
+                traverseSuggestion([...prefix, candidate], node);
+        if (!isFinished)
+            continue;
+        for (const [test, { to }] of nodeDef.dynamics) {
+            if (to === NODE_ERRORED)
+                continue;
+            const tokens = suggest(test, state);
+            if (tokens === null)
+                continue;
+            for (const token of tokens) {
+                traverseSuggestion([...prefix, token], node);
+            }
+        }
+    }
+    return [...suggestions].sort();
+}
+function runMachine(machine, input) {
+    const branches = runMachineInternal(machine, [...input, END_OF_INPUT]);
+    return selectBestState(input, branches.map(({ state }) => {
+        return state;
+    }));
+}
+function trimSmallerBranches(branches) {
+    let maxPathSize = 0;
+    for (const { state } of branches)
+        if (state.path.length > maxPathSize)
+            maxPathSize = state.path.length;
+    return branches.filter(({ state }) => {
+        return state.path.length === maxPathSize;
+    });
+}
+function selectBestState(input, states) {
+    const terminalStates = states.filter(state => {
+        return state.selectedIndex !== null;
+    });
+    if (terminalStates.length === 0)
+        throw new Error();
+    const requiredOptionsSetStates = terminalStates.filter(state => state.requiredOptions.every(names => names.some(name => state.options.find(opt => opt.name === name))));
+    if (requiredOptionsSetStates.length === 0) {
+        throw new UnknownSyntaxError(input, terminalStates.map(state => ({
+            usage: state.candidateUsage,
+            reason: null,
+        })));
+    }
+    let maxPathSize = 0;
+    for (const state of requiredOptionsSetStates)
+        if (state.path.length > maxPathSize)
+            maxPathSize = state.path.length;
+    const bestPathBranches = requiredOptionsSetStates.filter(state => {
+        return state.path.length === maxPathSize;
+    });
+    const getPositionalCount = (state) => state.positionals.filter(({ extra }) => {
+        return !extra;
+    }).length + state.options.length;
+    const statesWithPositionalCount = bestPathBranches.map(state => {
+        return { state, positionalCount: getPositionalCount(state) };
+    });
+    let maxPositionalCount = 0;
+    for (const { positionalCount } of statesWithPositionalCount)
+        if (positionalCount > maxPositionalCount)
+            maxPositionalCount = positionalCount;
+    const bestPositionalStates = statesWithPositionalCount.filter(({ positionalCount }) => {
+        return positionalCount === maxPositionalCount;
+    }).map(({ state }) => {
+        return state;
+    });
+    const fixedStates = aggregateHelpStates(bestPositionalStates);
+    if (fixedStates.length > 1)
+        throw new AmbiguousSyntaxError(input, fixedStates.map(state => state.candidateUsage));
+    return fixedStates[0];
+}
+function aggregateHelpStates(states) {
+    const notHelps = [];
+    const helps = [];
+    for (const state of states) {
+        if (state.selectedIndex === HELP_COMMAND_INDEX) {
+            helps.push(state);
+        }
+        else {
+            notHelps.push(state);
+        }
+    }
+    if (helps.length > 0) {
+        notHelps.push({
+            ...basicHelpState,
+            path: findCommonPrefix(...helps.map(state => state.path)),
+            options: helps.reduce((options, state) => options.concat(state.options), []),
+        });
+    }
+    return notHelps;
+}
+function findCommonPrefix(firstPath, secondPath, ...rest) {
+    if (secondPath === undefined)
+        return Array.from(firstPath);
+    return findCommonPrefix(firstPath.filter((segment, i) => segment === secondPath[i]), ...rest);
+}
+function makeNode() {
+    return {
+        dynamics: [],
+        shortcuts: [],
+        statics: {},
+    };
+}
+function isTerminalNode(node) {
+    return node === NODE_SUCCESS || node === NODE_ERRORED;
+}
+function cloneTransition(input, offset = 0) {
+    return {
+        to: !isTerminalNode(input.to) ? input.to > 2 ? input.to + offset - 2 : input.to + offset : input.to,
+        reducer: input.reducer,
+    };
+}
+function cloneNode(input, offset = 0) {
+    const output = makeNode();
+    for (const [test, transition] of input.dynamics)
+        output.dynamics.push([test, cloneTransition(transition, offset)]);
+    for (const transition of input.shortcuts)
+        output.shortcuts.push(cloneTransition(transition, offset));
+    for (const [segment, transitions] of Object.entries(input.statics))
+        output.statics[segment] = transitions.map(transition => cloneTransition(transition, offset));
+    return output;
+}
+function registerDynamic(machine, from, test, to, reducer) {
+    machine.nodes[from].dynamics.push([
+        test,
+        { to, reducer: reducer },
+    ]);
+}
+function registerShortcut(machine, from, to, reducer) {
+    machine.nodes[from].shortcuts.push({ to, reducer: reducer });
+}
+function registerStatic(machine, from, test, to, reducer) {
+    const store = !Object.prototype.hasOwnProperty.call(machine.nodes[from].statics, test)
+        ? machine.nodes[from].statics[test] = []
+        : machine.nodes[from].statics[test];
+    store.push({ to, reducer: reducer });
+}
+function execute(store, callback, state, segment) {
+    // TypeScript's control flow can't properly narrow
+    // generic conditionals for some mysterious reason
+    if (Array.isArray(callback)) {
+        const [name, ...args] = callback;
+        return store[name](state, segment, ...args);
+    }
+    else {
+        return store[callback](state, segment);
+    }
+}
+function suggest(callback, state) {
+    const fn = Array.isArray(callback)
+        ? tests[callback[0]]
+        : tests[callback];
+    // @ts-ignore
+    if (typeof fn.suggest === `undefined`)
+        return null;
+    const args = Array.isArray(callback)
+        ? callback.slice(1)
+        : [];
+    // @ts-ignore
+    return fn.suggest(state, ...args);
+}
+const tests = {
+    always: () => {
+        return true;
+    },
+    isOptionLike: (state, segment) => {
+        return !state.ignoreOptions && (segment !== `-` && segment.startsWith(`-`));
+    },
+    isNotOptionLike: (state, segment) => {
+        return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`);
+    },
+    isOption: (state, segment, name, hidden) => {
+        return !state.ignoreOptions && segment === name;
+    },
+    isBatchOption: (state, segment, names) => {
+        return !state.ignoreOptions && BATCH_REGEX.test(segment) && [...segment.slice(1)].every(name => names.includes(`-${name}`));
+    },
+    isBoundOption: (state, segment, names, options) => {
+        const optionParsing = segment.match(BINDING_REGEX);
+        return !state.ignoreOptions && !!optionParsing && OPTION_REGEX.test(optionParsing[1]) && names.includes(optionParsing[1])
+            // Disallow bound options with no arguments (i.e. booleans)
+            && options.filter(opt => opt.names.includes(optionParsing[1])).every(opt => opt.allowBinding);
+    },
+    isNegatedOption: (state, segment, name) => {
+        return !state.ignoreOptions && segment === `--no-${name.slice(2)}`;
+    },
+    isHelp: (state, segment) => {
+        return !state.ignoreOptions && HELP_REGEX.test(segment);
+    },
+    isUnsupportedOption: (state, segment, names) => {
+        return !state.ignoreOptions && segment.startsWith(`-`) && OPTION_REGEX.test(segment) && !names.includes(segment);
+    },
+    isInvalidOption: (state, segment) => {
+        return !state.ignoreOptions && segment.startsWith(`-`) && !OPTION_REGEX.test(segment);
+    },
+};
+// @ts-ignore
+tests.isOption.suggest = (state, name, hidden = true) => {
+    return !hidden ? [name] : null;
+};
+const reducers = {
+    setCandidateState: (state, segment, candidateState) => {
+        return { ...state, ...candidateState };
+    },
+    setSelectedIndex: (state, segment, index) => {
+        return { ...state, selectedIndex: index };
+    },
+    pushBatch: (state, segment) => {
+        return { ...state, options: state.options.concat([...segment.slice(1)].map(name => ({ name: `-${name}`, value: true }))) };
+    },
+    pushBound: (state, segment) => {
+        const [, name, value] = segment.match(BINDING_REGEX);
+        return { ...state, options: state.options.concat({ name, value }) };
+    },
+    pushPath: (state, segment) => {
+        return { ...state, path: state.path.concat(segment) };
+    },
+    pushPositional: (state, segment) => {
+        return { ...state, positionals: state.positionals.concat({ value: segment, extra: false }) };
+    },
+    pushExtra: (state, segment) => {
+        return { ...state, positionals: state.positionals.concat({ value: segment, extra: true }) };
+    },
+    pushExtraNoLimits: (state, segment) => {
+        return { ...state, positionals: state.positionals.concat({ value: segment, extra: NoLimits }) };
+    },
+    pushTrue: (state, segment, name = segment) => {
+        return { ...state, options: state.options.concat({ name: segment, value: true }) };
+    },
+    pushFalse: (state, segment, name = segment) => {
+        return { ...state, options: state.options.concat({ name, value: false }) };
+    },
+    pushUndefined: (state, segment) => {
+        return { ...state, options: state.options.concat({ name: segment, value: undefined }) };
+    },
+    pushStringValue: (state, segment) => {
+        var _a;
+        const copy = { ...state, options: [...state.options] };
+        const lastOption = state.options[state.options.length - 1];
+        lastOption.value = ((_a = lastOption.value) !== null && _a !== void 0 ? _a : []).concat([segment]);
+        return copy;
+    },
+    setStringValue: (state, segment) => {
+        const copy = { ...state, options: [...state.options] };
+        const lastOption = state.options[state.options.length - 1];
+        lastOption.value = segment;
+        return copy;
+    },
+    inhibateOptions: (state) => {
+        return { ...state, ignoreOptions: true };
+    },
+    useHelp: (state, segment, command) => {
+        const [, /* name */ , index] = segment.match(HELP_REGEX);
+        if (typeof index !== `undefined`) {
+            return { ...state, options: [{ name: `-c`, value: String(command) }, { name: `-i`, value: index }] };
+        }
+        else {
+            return { ...state, options: [{ name: `-c`, value: String(command) }] };
+        }
+    },
+    setError: (state, segment, errorMessage) => {
+        if (segment === END_OF_INPUT) {
+            return { ...state, errorMessage: `${errorMessage}.` };
+        }
+        else {
+            return { ...state, errorMessage: `${errorMessage} ("${segment}").` };
+        }
+    },
+    setOptionArityError: (state, segment) => {
+        const lastOption = state.options[state.options.length - 1];
+        return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` };
+    },
+};
+// ------------------------------------------------------------------------
+const NoLimits = Symbol();
+class CommandBuilder {
+    constructor(cliIndex, cliOpts) {
+        this.allOptionNames = [];
+        this.arity = { leading: [], trailing: [], extra: [], proxy: false };
+        this.options = [];
+        this.paths = [];
+        this.cliIndex = cliIndex;
+        this.cliOpts = cliOpts;
+    }
+    addPath(path) {
+        this.paths.push(path);
+    }
+    setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) {
+        Object.assign(this.arity, { leading, trailing, extra, proxy });
+    }
+    addPositional({ name = `arg`, required = true } = {}) {
+        if (!required && this.arity.extra === NoLimits)
+            throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`);
+        if (!required && this.arity.trailing.length > 0)
+            throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`);
+        if (!required && this.arity.extra !== NoLimits) {
+            this.arity.extra.push(name);
+        }
+        else if (this.arity.extra !== NoLimits && this.arity.extra.length === 0) {
+            this.arity.leading.push(name);
+        }
+        else {
+            this.arity.trailing.push(name);
+        }
+    }
+    addRest({ name = `arg`, required = 0 } = {}) {
+        if (this.arity.extra === NoLimits)
+            throw new Error(`Infinite lists cannot be declared multiple times in the same command`);
+        if (this.arity.trailing.length > 0)
+            throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`);
+        for (let t = 0; t < required; ++t)
+            this.addPositional({ name });
+        this.arity.extra = NoLimits;
+    }
+    addProxy({ required = 0 } = {}) {
+        this.addRest({ required });
+        this.arity.proxy = true;
+    }
+    addOption({ names, description, arity = 0, hidden = false, required = false, allowBinding = true }) {
+        if (!allowBinding && arity > 1)
+            throw new Error(`The arity cannot be higher than 1 when the option only supports the --arg=value syntax`);
+        if (!Number.isInteger(arity))
+            throw new Error(`The arity must be an integer, got ${arity}`);
+        if (arity < 0)
+            throw new Error(`The arity must be positive, got ${arity}`);
+        this.allOptionNames.push(...names);
+        this.options.push({ names, description, arity, hidden, required, allowBinding });
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    usage({ detailed = true, inlineOptions = true } = {}) {
+        const segments = [this.cliOpts.binaryName];
+        const detailedOptionList = [];
+        if (this.paths.length > 0)
+            segments.push(...this.paths[0]);
+        if (detailed) {
+            for (const { names, arity, hidden, description, required } of this.options) {
+                if (hidden)
+                    continue;
+                const args = [];
+                for (let t = 0; t < arity; ++t)
+                    args.push(` #${t}`);
+                const definition = `${names.join(`,`)}${args.join(``)}`;
+                if (!inlineOptions && description) {
+                    detailedOptionList.push({ definition, description, required });
+                }
+                else {
+                    segments.push(required ? `<${definition}>` : `[${definition}]`);
+                }
+            }
+            segments.push(...this.arity.leading.map(name => `<${name}>`));
+            if (this.arity.extra === NoLimits)
+                segments.push(`...`);
+            else
+                segments.push(...this.arity.extra.map(name => `[${name}]`));
+            segments.push(...this.arity.trailing.map(name => `<${name}>`));
+        }
+        const usage = segments.join(` `);
+        return { usage, options: detailedOptionList };
+    }
+    compile() {
+        if (typeof this.context === `undefined`)
+            throw new Error(`Assertion failed: No context attached`);
+        const machine = makeStateMachine();
+        let firstNode = NODE_INITIAL;
+        const candidateUsage = this.usage().usage;
+        const requiredOptions = this.options
+            .filter(opt => opt.required)
+            .map(opt => opt.names);
+        firstNode = injectNode(machine, makeNode());
+        registerStatic(machine, NODE_INITIAL, START_OF_INPUT, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]);
+        const positionalArgument = this.arity.proxy
+            ? `always`
+            : `isNotOptionLike`;
+        const paths = this.paths.length > 0
+            ? this.paths
+            : [[]];
+        for (const path of paths) {
+            let lastPathNode = firstNode;
+            // We allow options to be specified before the path. Note that we
+            // only do this when there is a path, otherwise there would be
+            // some redundancy with the options attached later.
+            if (path.length > 0) {
+                const optionPathNode = injectNode(machine, makeNode());
+                registerShortcut(machine, lastPathNode, optionPathNode);
+                this.registerOptions(machine, optionPathNode);
+                lastPathNode = optionPathNode;
+            }
+            for (let t = 0; t < path.length; ++t) {
+                const nextPathNode = injectNode(machine, makeNode());
+                registerStatic(machine, lastPathNode, path[t], nextPathNode, `pushPath`);
+                lastPathNode = nextPathNode;
+            }
+            if (this.arity.leading.length > 0 || !this.arity.proxy) {
+                const helpNode = injectNode(machine, makeNode());
+                registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
+                registerStatic(machine, helpNode, END_OF_INPUT, NODE_SUCCESS, [`setSelectedIndex`, HELP_COMMAND_INDEX]);
+                this.registerOptions(machine, lastPathNode);
+            }
+            if (this.arity.leading.length > 0)
+                registerStatic(machine, lastPathNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+            let lastLeadingNode = lastPathNode;
+            for (let t = 0; t < this.arity.leading.length; ++t) {
+                const nextLeadingNode = injectNode(machine, makeNode());
+                if (!this.arity.proxy || t + 1 !== this.arity.leading.length)
+                    this.registerOptions(machine, nextLeadingNode);
+                if (this.arity.trailing.length > 0 || t + 1 !== this.arity.leading.length)
+                    registerStatic(machine, nextLeadingNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+                registerDynamic(machine, lastLeadingNode, `isNotOptionLike`, nextLeadingNode, `pushPositional`);
+                lastLeadingNode = nextLeadingNode;
+            }
+            let lastExtraNode = lastLeadingNode;
+            if (this.arity.extra === NoLimits || this.arity.extra.length > 0) {
+                const extraShortcutNode = injectNode(machine, makeNode());
+                registerShortcut(machine, lastLeadingNode, extraShortcutNode);
+                if (this.arity.extra === NoLimits) {
+                    const extraNode = injectNode(machine, makeNode());
+                    if (!this.arity.proxy)
+                        this.registerOptions(machine, extraNode);
+                    registerDynamic(machine, lastLeadingNode, positionalArgument, extraNode, `pushExtraNoLimits`);
+                    registerDynamic(machine, extraNode, positionalArgument, extraNode, `pushExtraNoLimits`);
+                    registerShortcut(machine, extraNode, extraShortcutNode);
+                }
+                else {
+                    for (let t = 0; t < this.arity.extra.length; ++t) {
+                        const nextExtraNode = injectNode(machine, makeNode());
+                        if (!this.arity.proxy || t > 0)
+                            this.registerOptions(machine, nextExtraNode);
+                        registerDynamic(machine, lastExtraNode, positionalArgument, nextExtraNode, `pushExtra`);
+                        registerShortcut(machine, nextExtraNode, extraShortcutNode);
+                        lastExtraNode = nextExtraNode;
+                    }
+                }
+                lastExtraNode = extraShortcutNode;
+            }
+            if (this.arity.trailing.length > 0)
+                registerStatic(machine, lastExtraNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+            let lastTrailingNode = lastExtraNode;
+            for (let t = 0; t < this.arity.trailing.length; ++t) {
+                const nextTrailingNode = injectNode(machine, makeNode());
+                if (!this.arity.proxy)
+                    this.registerOptions(machine, nextTrailingNode);
+                if (t + 1 < this.arity.trailing.length)
+                    registerStatic(machine, nextTrailingNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+                registerDynamic(machine, lastTrailingNode, `isNotOptionLike`, nextTrailingNode, `pushPositional`);
+                lastTrailingNode = nextTrailingNode;
+            }
+            registerDynamic(machine, lastTrailingNode, positionalArgument, NODE_ERRORED, [`setError`, `Extraneous positional argument`]);
+            registerStatic(machine, lastTrailingNode, END_OF_INPUT, NODE_SUCCESS, [`setSelectedIndex`, this.cliIndex]);
+        }
+        return {
+            machine,
+            context: this.context,
+        };
+    }
+    registerOptions(machine, node) {
+        registerDynamic(machine, node, [`isOption`, `--`], node, `inhibateOptions`);
+        registerDynamic(machine, node, [`isBatchOption`, this.allOptionNames], node, `pushBatch`);
+        registerDynamic(machine, node, [`isBoundOption`, this.allOptionNames, this.options], node, `pushBound`);
+        registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], NODE_ERRORED, [`setError`, `Unsupported option name`]);
+        registerDynamic(machine, node, [`isInvalidOption`], NODE_ERRORED, [`setError`, `Invalid option name`]);
+        for (const option of this.options) {
+            const longestName = option.names.reduce((longestName, name) => {
+                return name.length > longestName.length ? name : longestName;
+            }, ``);
+            if (option.arity === 0) {
+                for (const name of option.names) {
+                    registerDynamic(machine, node, [`isOption`, name, option.hidden || name !== longestName], node, `pushTrue`);
+                    if (name.startsWith(`--`) && !name.startsWith(`--no-`)) {
+                        registerDynamic(machine, node, [`isNegatedOption`, name], node, [`pushFalse`, name]);
+                    }
+                }
+            }
+            else {
+                // We inject a new node at the end of the state machine
+                let lastNode = injectNode(machine, makeNode());
+                // We register transitions from the starting node to this new node
+                for (const name of option.names)
+                    registerDynamic(machine, node, [`isOption`, name, option.hidden || name !== longestName], lastNode, `pushUndefined`);
+                // For each argument, we inject a new node at the end and we
+                // register a transition from the current node to this new node
+                for (let t = 0; t < option.arity; ++t) {
+                    const nextNode = injectNode(machine, makeNode());
+                    // We can provide better errors when another option or END_OF_INPUT is encountered
+                    registerStatic(machine, lastNode, END_OF_INPUT, NODE_ERRORED, `setOptionArityError`);
+                    registerDynamic(machine, lastNode, `isOptionLike`, NODE_ERRORED, `setOptionArityError`);
+                    // If the option has a single argument, no need to store it in an array
+                    const action = option.arity === 1
+                        ? `setStringValue`
+                        : `pushStringValue`;
+                    registerDynamic(machine, lastNode, `isNotOptionLike`, nextNode, action);
+                    lastNode = nextNode;
+                }
+                // In the end, we register a shortcut from
+                // the last node back to the starting node
+                registerShortcut(machine, lastNode, node);
+            }
+        }
+    }
+}
+class CliBuilder {
+    constructor({ binaryName = `...` } = {}) {
+        this.builders = [];
+        this.opts = { binaryName };
+    }
+    static build(cbs, opts = {}) {
+        return new CliBuilder(opts).commands(cbs).compile();
+    }
+    getBuilderByIndex(n) {
+        if (!(n >= 0 && n < this.builders.length))
+            throw new Error(`Assertion failed: Out-of-bound command index (${n})`);
+        return this.builders[n];
+    }
+    commands(cbs) {
+        for (const cb of cbs)
+            cb(this.command());
+        return this;
+    }
+    command() {
+        const builder = new CommandBuilder(this.builders.length, this.opts);
+        this.builders.push(builder);
+        return builder;
+    }
+    compile() {
+        const machines = [];
+        const contexts = [];
+        for (const builder of this.builders) {
+            const { machine, context } = builder.compile();
+            machines.push(machine);
+            contexts.push(context);
+        }
+        const machine = makeAnyOfMachine(machines);
+        simplifyMachine(machine);
+        return {
+            machine,
+            contexts,
+            process: (input) => {
+                return runMachine(machine, input);
+            },
+            suggest: (input, partial) => {
+                return suggestMachine(machine, input, partial);
+            },
+        };
+    }
+}
+
+export { CliBuilder, CommandBuilder, NoLimits, aggregateHelpStates, cloneNode, cloneTransition, debug, debugMachine, execute, injectNode, isTerminalNode, makeAnyOfMachine, makeNode, makeStateMachine, reducers, registerDynamic, registerShortcut, registerStatic, runMachineInternal, selectBestState, simplifyMachine, suggest, tests, trimSmallerBranches };