@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/cli/index.js

@@ -1,333 +0,0 @@
-import * as path from "node:path";
-import { FlowError, asMessage } from "../flow-error.js";
-import { writeDraftArtifact } from "./draft-artifact.js";
-import { compileBindDraftFlags } from "../core/draft.js";
-import { handleCliError } from "./render/errors.js";
-import { FLAG_SPECS } from "./flags.js";
-import { renderCliCommandHelp as renderCliCommandHelpText, renderCliHelp as renderCliHelpText, } from "./help.js";
-import { isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
-import { getCommandMetadata } from "./commands/metadata.js";
-import { loadCommandHandler } from "./commands/registry.js";
-import { shellQuote } from "./render/format.js";
-import { writeSuccessResponse } from "./render/success-response.js";
-import { writeCliOutput } from "./output-stream-error-policy.js";
-function commandRequiresStdin(command) {
-    const stdin = getCommandMetadata(command).stdin;
-    return stdin.mode === "document" && stdin.selector.required;
-}
-function commandAcceptsOptionalStdin(command) {
-    const stdin = getCommandMetadata(command).stdin;
-    return stdin.mode === "document" && !stdin.selector.required;
-}
-function commandSavesFailedStdin(command) {
-    return (commandRequiresStdin(command) || commandAcceptsOptionalStdin(command)) && command !== "call";
-}
-function hasBindDomainFlags(flags) {
-    return (flags.bindTitle !== undefined
-        || flags.bindContext !== undefined
-        || flags.bindObjective !== undefined
-        || flags.bindDesign !== undefined
-        || flags.bindScope !== undefined
-        || flags.bindCriteria !== undefined
-        || flags.bindVerification !== undefined);
-}
-function prepareBindInput(stdin, flags, selectsStdin) {
-    if (flags.contractId !== undefined)
-        return "";
-    const nonblankStdin = stdin.trim().length > 0;
-    const domainFlags = hasBindDomainFlags(flags);
-    if (flags.dryRun && flags.draftOnly) {
-        throw new FlowError("INVALID_USAGE", "--dry-run cannot be combined with --draft-only");
-    }
-    if (selectsStdin && domainFlags) {
-        throw new FlowError("INVALID_USAGE", "bind accepts either stdin Markdown or domain flags, not both");
-    }
-    if (domainFlags) {
-        const missing = [];
-        if (flags.bindTitle === undefined)
-            missing.push("--title");
-        if (flags.bindContext === undefined)
-            missing.push("--context");
-        if (flags.bindObjective === undefined)
-            missing.push("--objective");
-        if (flags.bindDesign === undefined)
-            missing.push("--design");
-        if (flags.bindScope === undefined)
-            missing.push("--scope");
-        if (flags.bindCriteria === undefined)
-            missing.push("--criteria");
-        if (missing.length > 0 && (flags.bindTaskIds?.length ?? 0) === 0) {
-            throw new FlowError("EMPTY_PARAM", `bind flag mode requires --title, --context, --objective, --design, --scope, and --criteria; missing ${missing.join(", ")}`);
-        }
-        return compileBindDraftFlags({
-            title: flags.bindTitle,
-            context: flags.bindContext,
-            objective: flags.bindObjective,
-            design: flags.bindDesign,
-            scope: flags.bindScope,
-            criteria: flags.bindCriteria,
-            verification: flags.bindVerification,
-        });
-    }
-    if (!nonblankStdin) {
-        // --task may supply title/objective defaults; core merges and reports missing sections.
-        if (flags.bindTaskIds !== undefined && flags.bindTaskIds.length > 0) {
-            return "";
-        }
-        const message = selectsStdin
-            ? `No Markdown input received on stdin.\n\nExample:\n  ${usageExample("bind")}`
-            : "bind requires literal '-' for Markdown input or the required domain flags";
-        throw new FlowError(selectsStdin ? "STDIN_EMPTY" : "EMPTY_PARAM", message);
-    }
-    return stdin;
-}
-async function readStdin() {
-    let data = "";
-    process.stdin.setEncoding("utf-8");
-    for await (const chunk of process.stdin)
-        data += String(chunk);
-    return data;
-}
-function makeAbortSignal() {
-    const controller = new AbortController();
-    process.once("SIGINT", () => controller.abort());
-    process.once("SIGTERM", () => controller.abort());
-    return controller.signal;
-}
-function responseText(response) {
-    return response.text;
-}
-async function saveFailedStdin(input) {
-    if (!input.content.trim())
-        return undefined;
-    return await writeDraftArtifact({
-        cwd: input.cwd,
-        title: `${input.command.replace(/\s+/g, "-")}-stdin`,
-        content: input.content,
-    });
-}
-/**
- * Rebuild bind flags for a failed-stdin retry in deterministic shell-safe order.
- * Order follows bind usage/parse authority: cwd, repo, after, exclusive,
- * draft-only, task. Domain-flag bind does not save stdin, so title/objective/
- * scope/criteria are not reconstructed. --dry-run never reaches this path.
- */
-function bindRetryFlagTokens(flags) {
-    const tokens = [];
-    if (flags.cwd !== undefined) {
-        tokens.push("--cwd", shellQuote(flags.cwd));
-    }
-    if (flags.repo !== undefined) {
-        tokens.push("--repo", shellQuote(flags.repo));
-    }
-    for (const after of flags.after ?? []) {
-        tokens.push("--after", shellQuote(after));
-    }
-    if (flags.exclusive === true) {
-        tokens.push("--exclusive");
-    }
-    if (flags.draftOnly === true) {
-        tokens.push("--draft-only");
-    }
-    if (flags.bindTaskIds !== undefined) {
-        for (const taskId of flags.bindTaskIds) {
-            tokens.push("--task", shellQuote(taskId));
-        }
-    }
-    return tokens;
-}
-function retryHint(input) {
-    const draftArg = input.flags.cwd === undefined
-        ? shellQuote(input.draftPath)
-        : shellQuote(path.resolve(input.cwd, input.draftPath));
-    if (input.command === "bind") {
-        const flagTokens = bindRetryFlagTokens(input.flags);
-        const flagPart = flagTokens.length > 0 ? ` ${flagTokens.join(" ")}` : "";
-        return `Retry: keiyaku bind${flagPart} - < ${draftArg}`;
-    }
-    if (input.flags.cwd === undefined) {
-        return `Retry: keiyaku ${input.command} - < ${shellQuote(input.draftPath)}`;
-    }
-    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} - < ${draftArg}`;
-}
-async function printFailure(error, cwd) {
-    const response = await handleCliError({
-        error,
-        cwd,
-        logLabel: "cli",
-    });
-    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
-}
-function failureExitCode(error) {
-    return error instanceof Error && error.name === "AbortError" ? 130 : 1;
-}
-async function handleFailureAfterStdin(input) {
-    if (input.response) {
-        await writeCliOutput(process.stderr, `${responseText(input.response)}\n`);
-    }
-    else {
-        await printFailure(input.error ?? new Error("Unknown CLI failure"), input.cwd);
-    }
-    if (input.saveStdin === false || !commandSavesFailedStdin(input.command)) {
-        return 1;
-    }
-    try {
-        const draftPath = await saveFailedStdin({
-            cwd: input.cwd,
-            command: input.command,
-            content: input.stdin,
-        });
-        if (draftPath) {
-            await writeCliOutput(process.stderr, `\nSaved stdin input to ${draftPath}.\n${retryHint({
-                command: input.command,
-                draftPath,
-                cwd: input.cwd,
-                flags: input.flags,
-            })}\n`);
-        }
-    }
-    catch (draftError) {
-        await writeCliOutput(process.stderr, `\nFailed to save stdin input: ${asMessage(draftError)}\n`);
-    }
-    return 1;
-}
-async function runResponse(command, flags, stdin, positional) {
-    const signal = makeAbortSignal();
-    const handler = await loadCommandHandler(command);
-    return await handler(stdin, flags, signal, positional);
-}
-function selectedArgument(parsed) {
-    const stdin = getCommandMetadata(parsed.command).stdin;
-    if (stdin.selector === undefined)
-        return undefined;
-    if (stdin.selector.kind === "positional") {
-        const token = parsed.positional[stdin.selector.index];
-        if (token === undefined && !stdin.selector.required)
-            return undefined;
-        return { token, replace: () => parsed.flags };
-    }
-    const flagName = stdin.selector.names.find((name) => parsed.flags[name] !== undefined);
-    const token = flagName === undefined ? undefined : parsed.flags[flagName];
-    if (token === undefined && !stdin.selector.required)
-        return undefined;
-    return {
-        token,
-        replace: (value) => flagName === undefined ? parsed.flags : ({ ...parsed.flags, [flagName]: value }),
-    };
-}
-async function resolveCliInput(parsed) {
-    const stdinMeta = getCommandMetadata(parsed.command).stdin;
-    const selected = selectedArgument(parsed);
-    const token = selected?.token;
-    const selectsStdin = token === "-";
-    const piped = selectsStdin ? await readStdin() : "";
-    const input = selectsStdin ? piped : token ?? "";
-    if (stdinMeta.selector?.required && token === undefined) {
-        const message = stdinMeta.mode === "document"
-            ? `${parsed.command} requires literal '-' to read Markdown from stdin`
-            : `${parsed.command} body cannot be empty`;
-        throw new FlowError("EMPTY_PARAM", message);
-    }
-    if (token !== undefined && stdinMeta.selector?.rejectBlank && !input.trim()) {
-        const message = stdinMeta.mode === "document"
-            ? `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`
-            : selectsStdin
-                ? parsed.command === "task add"
-                    ? "task add received no task document on stdin"
-                    : `${parsed.command} received no body on stdin`
-                : parsed.command === "task add"
-                    ? "task add title cannot be empty"
-                    : `${parsed.command} body cannot be empty`;
-        throw new FlowError(selectsStdin ? "STDIN_EMPTY" : "EMPTY_PARAM", message);
-    }
-    return { stdin: input, flags: selected?.replace(input) ?? parsed.flags, selectsStdin };
-}
-function usageExample(command) {
-    const meta = getCommandMetadata(command);
-    return meta.examples?.[0] ?? meta.usage[0] ?? `keiyaku ${command}`;
-}
-export async function runCliCommand(tokens) {
-    let parsed;
-    try {
-        parsed = parseCliArgs(tokens);
-    }
-    catch (error) {
-        await printFailure(error, process.cwd());
-        return isPetitionDryRunInvocation(tokens) ? 2 : 1;
-    }
-    if (parsed.helpRequested) {
-        await writeCliOutput(process.stdout, `${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
-        return 0;
-    }
-    const cwd = parsed.flags.cwd ?? process.cwd();
-    let stdin;
-    let selectsStdin = false;
-    try {
-        const resolved = await resolveCliInput(parsed);
-        stdin = resolved.stdin;
-        selectsStdin = resolved.selectsStdin;
-        parsed = { ...parsed, flags: resolved.flags };
-    }
-    catch (error) {
-        await printFailure(error, cwd);
-        return 1;
-    }
-    // Bind input compilation is side-effect free. Dry-run then performs the same
-    // repository admission as bind but does not persist an artifact on failure.
-    if (parsed.command === "bind") {
-        try {
-            stdin = prepareBindInput(stdin, parsed.flags, selectsStdin);
-        }
-        catch (error) {
-            await printFailure(error, cwd);
-            return 1;
-        }
-    }
-    let response;
-    try {
-        response = await runResponse(parsed.command, parsed.flags, stdin, parsed.positional);
-    }
-    catch (error) {
-        if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun && parsed.flags.contractId === undefined)) {
-            return await handleFailureAfterStdin({
-                error,
-                cwd,
-                command: parsed.command,
-                stdin,
-                flags: parsed.flags,
-                saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
-            });
-        }
-        await printFailure(error, cwd);
-        if (parsed.command === "petition" && parsed.flags.dryRun)
-            return 2;
-        return failureExitCode(error);
-    }
-    const success = !response.isDomainFailure && (!response.payload || !("error" in response.payload));
-    if (success) {
-        await writeSuccessResponse(parsed.command, parsed.flags, response);
-        return response.exitCode ?? 0;
-    }
-    if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun && parsed.flags.contractId === undefined)) {
-        return await handleFailureAfterStdin({
-            response,
-            cwd,
-            command: parsed.command,
-            stdin,
-            flags: parsed.flags,
-            saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
-        });
-    }
-    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
-    return response.exitCode ?? 1;
-}
-export function renderCliCommandHelp(command) {
-    const meta = getCommandMetadata(command);
-    return renderCliCommandHelpText(command, meta, FLAG_SPECS);
-}
-function resolveCliHelpCommand(command) {
-    return command;
-}
-export function renderCliHelp(version) {
-    return renderCliHelpText(version);
-}

package/build/cli/missing-subcommand.js

@@ -1,7 +0,0 @@
-import { FlowError } from "../flow-error.js";
-export function formatSubcommandList(subcommands) {
-    return subcommands.length < 2 ? (subcommands[0] ?? "") : `${subcommands.slice(0, -1).join(", ")} or ${subcommands.at(-1)}`;
-}
-export function missingSubcommandError(name, subcommands) {
-    return new FlowError("EMPTY_PARAM", `${name} requires subcommand: ${formatSubcommandList(subcommands)}`);
-}

package/build/cli/output-stream-error-policy.js

@@ -1,31 +0,0 @@
-export function isBrokenPipeError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "EPIPE");
-}
-/** Resolve only after Node reports that this chunk has been flushed. */
-export function writeCliOutput(stream, chunk) {
-    return new Promise((resolve, reject) => {
-        stream.write(chunk, (error) => {
-            if (error && !isBrokenPipeError(error)) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
-/**
- * Install a process-level broken-pipe policy on each supplied stream.
- * EPIPE is silent; every other emitted value is rethrown unchanged.
- */
-export function installCliOutputStreamErrorPolicy(...streams) {
-    for (const stream of streams) {
-        stream.on("error", (error) => {
-            if (isBrokenPipeError(error))
-                return;
-            throw error;
-        });
-    }
-}

package/build/cli/parse-flags.js

@@ -1,301 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { getCommandMetadata } from "./commands/metadata.js";
-import { BOOLEAN_FLAGS, CONTROL_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
-import { normalizeContractAddress, parseWaitTimeout } from "./parse-metadata.js";
-function allowedFlagsForParse(command) {
-    const meta = getCommandMetadata(command);
-    return meta.parseFlags ?? meta.flags;
-}
-export function parseFlagName(raw) {
-    return raw.slice(2);
-}
-export function assertAllowedFlag(command, name) {
-    if (!allowedFlagsForParse(command).includes(name)) {
-        throw new FlowError("UNKNOWN_OPTION", `option --${name} is not valid for ${command}`);
-    }
-}
-export function assignFlag(flags, name, value) {
-    switch (name) {
-        case "cwd":
-            flags.cwd = String(value);
-            return;
-        case "repo":
-            flags.repo = String(value);
-            return;
-        case "contract":
-            flags.contractId = normalizeContractAddress(String(value));
-            flags.contractAddressSource = "explicit-flag";
-            return;
-        case "akuma":
-            flags.akuma = String(value);
-            return;
-        case "projection":
-            flags.projection = String(value);
-            return;
-        case "alias":
-            flags.alias = String(value);
-            return;
-        case "timeout":
-        case "wait":
-            flags.timeoutMs = parseWaitTimeout(String(value));
-            return;
-        case "model":
-            flags.model = String(value);
-            return;
-        case "effort":
-            flags.effort = String(value);
-            return;
-        case "incognito":
-            flags.incognito = Boolean(value);
-            return;
-        case "bare":
-            flags.bare = Boolean(value);
-            return;
-        case "detach":
-            flags.detach = Boolean(value);
-            return;
-        case "interrupt":
-            flags.interrupt = Boolean(value);
-            return;
-        case "draft-only":
-            flags.draftOnly = Boolean(value);
-            return;
-        case "exclusive":
-            flags.exclusive = Boolean(value);
-            return;
-        case "place":
-            if (flags.bindPlace !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --place may only be specified once");
-            }
-            flags.bindPlace = String(value);
-            return;
-        case "objective":
-            if (flags.bindObjective !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --objective may only be specified once");
-            }
-            flags.bindObjective = String(value);
-            return;
-        case "context":
-            if (flags.bindContext !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --context may only be specified once");
-            }
-            flags.bindContext = String(value);
-            return;
-        case "design":
-            if (flags.bindDesign !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --design may only be specified once");
-            }
-            flags.bindDesign = String(value);
-            return;
-        case "scope":
-            flags.bindScope = [...(flags.bindScope ?? []), String(value)];
-            return;
-        case "criteria":
-            if (flags.bindCriteria !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --criteria may only be specified once");
-            }
-            flags.bindCriteria = String(value);
-            return;
-        case "verification":
-            if (flags.bindVerification !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --verification may only be specified once");
-            }
-            flags.bindVerification = String(value);
-            return;
-        case "task":
-            flags.bindTaskIds = [...(flags.bindTaskIds ?? []), String(value)];
-            return;
-        case "after":
-            flags.after = [...(flags.after ?? []), String(value)];
-            return;
-        case "force":
-            flags.force = Boolean(value);
-            return;
-        case "reason":
-            flags.reason = String(value);
-            return;
-        case "dry-run":
-            flags.dryRun = Boolean(value);
-            return;
-        case "check":
-            flags.check = Boolean(value);
-            return;
-        case "append-scope":
-            flags.appendScope = [...(flags.appendScope ?? []), String(value)];
-            return;
-        case "renew":
-            flags.renewBeforePetition = Boolean(value);
-            return;
-        case "audit":
-            flags.renewAudit = Boolean(value);
-            return;
-        case "continue":
-            flags.renewContinue = Boolean(value);
-            return;
-        case "abort":
-            flags.renewAbort = Boolean(value);
-            return;
-        case "shell":
-            flags.shell = String(value);
-            return;
-        case "word":
-            flags.word = String(value);
-            return;
-        case "previous":
-            flags.previous = String(value);
-            return;
-        case "complete":
-            flags.complete = Boolean(value);
-            return;
-        case "all":
-            flags.all = Boolean(value);
-            return;
-        case "any":
-            flags.any = Boolean(value);
-            return;
-        case "target":
-            if (flags.target !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --target may only be specified once");
-            }
-            flags.target = String(value);
-            return;
-        case "json":
-            flags.json = Boolean(value);
-            return;
-        case "diff-budget": {
-            const parsed = Number(String(value));
-            if (!Number.isSafeInteger(parsed) || parsed < 0) {
-                throw new FlowError("INVALID_USAGE", "option --diff-budget requires a non-negative safe integer byte count");
-            }
-            flags.auditDiffBudgetBytes = parsed;
-            return;
-        }
-        case "skip-diff-body":
-            flags.auditSkipDiffBody = Boolean(value);
-            return;
-        case "done":
-            flags.done = Boolean(value);
-            return;
-        case "filter":
-            flags.taskFilters = [...(flags.taskFilters ?? []), String(value)];
-            return;
-        case "sort":
-            if (flags.taskSort !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --sort may only be specified once");
-            }
-            flags.taskSort = String(value);
-            return;
-        case "limit": {
-            const parsed = Number(String(value));
-            if (!Number.isSafeInteger(parsed) || parsed < 1) {
-                throw new FlowError("INVALID_USAGE", "option --limit requires a positive safe integer entry count");
-            }
-            flags.historyLimit = parsed;
-            return;
-        }
-        case "offset": {
-            const parsed = Number(String(value));
-            if (!Number.isSafeInteger(parsed) || parsed < 0) {
-                throw new FlowError("INVALID_USAGE", "option --offset requires a non-negative safe integer entry count");
-            }
-            flags.historyOffset = parsed;
-            return;
-        }
-        case "entry": {
-            const parsed = Number(String(value));
-            if (!Number.isSafeInteger(parsed) || parsed < 0) {
-                throw new FlowError("INVALID_USAGE", "option --entry requires a non-negative safe integer retained entry index");
-            }
-            flags.historyEntry = parsed;
-            return;
-        }
-        case "raw":
-            flags.historyRaw = Boolean(value);
-            return;
-        case "pri": {
-            const raw = String(value);
-            if (!/^[0-3]$/.test(raw)) {
-                throw new FlowError("INVALID_USAGE", "task priority must be an integer from 0 through 3");
-            }
-            if (flags.taskPri !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --pri may only be specified once");
-            }
-            flags.taskPri = Number(raw);
-            return;
-        }
-        case "needs":
-            flags.taskNeeds = [...(flags.taskNeeds ?? []), String(value)];
-            return;
-        case "drop-needs":
-            flags.taskDropNeeds = [...(flags.taskDropNeeds ?? []), String(value)];
-            return;
-        case "from":
-            flags.taskFrom = [...(flags.taskFrom ?? []), String(value)];
-            return;
-        case "supersedes":
-            flags.taskSupersedes = [...(flags.taskSupersedes ?? []), String(value)];
-            return;
-        case "drop-supersedes":
-            flags.taskDropSupersedes = [...(flags.taskDropSupersedes ?? []), String(value)];
-            return;
-        case "relates-to":
-            flags.taskRelatesTo = [...(flags.taskRelatesTo ?? []), String(value)];
-            return;
-        case "drop-relates-to":
-            flags.taskDropRelatesTo = [...(flags.taskDropRelatesTo ?? []), String(value)];
-            return;
-        case "parent":
-            if (flags.taskParent !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --parent may only be specified once");
-            }
-            flags.taskParent = String(value);
-            return;
-        case "no-parent":
-            flags.taskNoParent = Boolean(value);
-            return;
-        case "title":
-            if (flags.taskTitle !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --title may only be specified once");
-            }
-            flags.taskTitle = String(value);
-            return;
-        case "body":
-            if (flags.taskBody !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --body may only be specified once");
-            }
-            flags.taskBody = String(value);
-            return;
-        case "append":
-            if (flags.taskAppend !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --append may only be specified once");
-            }
-            flags.taskAppend = String(value);
-            return;
-        case "note":
-            if (flags.taskNote !== undefined) {
-                throw new FlowError("INVALID_USAGE", "option --note may only be specified once");
-            }
-            flags.taskNote = String(value);
-            return;
-        default:
-            throw new FlowError("UNKNOWN_OPTION", `unknown option: --${name}`);
-    }
-}
-export function readValueFlag(name, token, eq, tokens, index) {
-    if (eq !== -1) {
-        const value = token.slice(eq + 1);
-        if (value === "" && name !== "target" && name !== "body") {
-            throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-        }
-        return { value, nextIndex: index };
-    }
-    const value = tokens[index + 1];
-    if (value === undefined || value === "--" || value.startsWith("--")) {
-        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-    }
-    if (value === "" && name !== "target" && name !== "body") {
-        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-    }
-    return { value, nextIndex: index + 1 };
-}
-export { BOOLEAN_FLAGS, CONTROL_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS };