@hyperfrontend/builder 0.1.0

package/_dependencies/@hyperfrontend/versioning/commits/index.cjs.js

@@ -0,0 +1,2457 @@
+'use strict';
+const node_path = require('node:path');
+const index_cjs_js = require('../../immutable-api-utils/built-in-copy/error/index.cjs.js');
+const index_cjs_js$2 = require('../../immutable-api-utils/built-in-copy/object/index.cjs.js');
+const node_readline = require('node:readline');
+const index_cjs_js$3 = require('../../immutable-api-utils/built-in-copy/promise/index.cjs.js');
+const index_cjs_js$4 = require('../../immutable-api-utils/built-in-copy/math/index.cjs.js');
+const index_cjs_js$5 = require('../../immutable-api-utils/built-in-copy/set/index.cjs.js');
+const node_child_process = require('node:child_process');
+require('../../immutable-api-utils/built-in-copy/date/index.cjs.js');
+require('../../immutable-api-utils/built-in-copy/number/index.cjs.js');
+const index_cjs_js$8 = require('../../immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$7 = require('../../project-scope/core/fs/index.cjs.js');
+const index_cjs_js$6 = require('../../project-scope/project/root/index.cjs.js');
+
+function typeToChoice(type) {
+    return {
+        label: type.name,
+        value: type.name,
+        ...(type.description && { hint: type.description }),
+    };
+}
+
+const SessionStatus = index_cjs_js$2.freeze({
+    Committed: 'committed',
+    Cancelled: 'cancelled',
+});
+
+const StepStatus = index_cjs_js$2.freeze({
+    Done: 'done',
+    Cancelled: 'cancelled',
+    Goto: 'goto',
+});
+function done() {
+    return { status: StepStatus.Done };
+}
+function cancelled(error) {
+    return error ? { status: StepStatus.Cancelled, error } : { status: StepStatus.Cancelled };
+}
+function goto(stepId) {
+    return { status: StepStatus.Goto, gotoStepId: stepId };
+}
+
+const Key = index_cjs_js$2.freeze({
+    Up: '\x1B[A',
+    Down: '\x1B[B',
+    Left: '\x1B[D',
+    Right: '\x1B[C',
+    Enter: '\r',
+    Space: ' ',
+    Tab: '\t',
+    Escape: '\x1B',
+    Backspace: '\x7F',
+    Delete: '\x1B[3~',
+    CtrlC: '\x03',
+});
+const Ansi = index_cjs_js$2.freeze({
+    ClearLine: '\x1B[2K',
+    CursorStart: '\r',
+    cursorUp: (n) => `\x1B[${n}A`,
+    cursorDown: (n) => `\x1B[${n}B`,
+    cursorLeft: (n) => `\x1B[${n}D`,
+    HideCursor: '\x1B[?25l',
+    ShowCursor: '\x1B[?25h',
+    SaveCursor: '\x1B7',
+    RestoreCursor: '\x1B8',
+    ClearToEnd: '\x1B[J',
+    Bold: '\x1B[1m',
+    Dim: '\x1B[2m',
+    Reset: '\x1B[0m',
+    Cyan: '\x1B[36m',
+    Green: '\x1B[32m',
+    Yellow: '\x1B[33m',
+    Red: '\x1B[31m',
+    Gray: '\x1B[90m',
+});
+function createTerminal(config = {}) {
+    const input = config.input ?? process.stdin;
+    const output = config.output ?? process.stdout;
+    let cancelled = false;
+    let rl;
+    const getReadline = () => {
+        if (!rl) {
+            rl = node_readline.createInterface({ input, output, terminal: true });
+        }
+        return rl;
+    };
+    const write = (text) => {
+        output.write(text);
+    };
+    const readKey = () => index_cjs_js$3.createPromise((resolve) => {
+        const wasRaw = input.isRaw;
+        if (input.setRawMode) {
+            input.setRawMode(true);
+        }
+        const onData = (data) => {
+            input.removeListener('data', onData);
+            if (input.setRawMode) {
+                input.setRawMode(wasRaw);
+            }
+            const key = data.toString();
+            if (key === Key.CtrlC) {
+                cancelled = true;
+            }
+            resolve(key);
+        };
+        input.once('data', onData);
+    });
+    const readLine = () => index_cjs_js$3.createPromise((resolve) => {
+        const readline = getReadline();
+        readline.once('line', (line) => {
+            resolve(line);
+        });
+        readline.once('close', () => {
+            cancelled = true;
+            resolve('');
+        });
+    });
+    const clearLines = (count) => {
+        if (count <= 0)
+            return;
+        for (let i = 0; i < count; i++) {
+            write(Ansi.CursorStart + Ansi.ClearLine);
+            if (i < count - 1) {
+                write(Ansi.cursorUp(1));
+            }
+        }
+    };
+    const close = () => {
+        if (rl) {
+            rl.close();
+            rl = undefined;
+        }
+        write(Ansi.ShowCursor);
+    };
+    return index_cjs_js$2.freeze({
+        write,
+        readKey,
+        readLine,
+        clearLines,
+        close,
+        isCancelled: () => cancelled,
+        cancel: () => {
+            cancelled = true;
+        },
+    });
+}
+
+const Symbol = index_cjs_js$2.freeze({
+    Pointer: '❯',
+    Radio: '◯',
+    RadioSelected: '◉',
+    Checkbox: '☐',
+    CheckboxSelected: '☑',
+    Check: '✔',
+    Cross: '✖',
+    Question: '?',
+    Ellipsis: '…',
+});
+const style = index_cjs_js$2.freeze({
+    bold: (text) => `${Ansi.Bold}${text}${Ansi.Reset}`,
+    dim: (text) => `${Ansi.Dim}${text}${Ansi.Reset}`,
+    cyan: (text) => `${Ansi.Cyan}${text}${Ansi.Reset}`,
+    green: (text) => `${Ansi.Green}${text}${Ansi.Reset}`,
+    yellow: (text) => `${Ansi.Yellow}${text}${Ansi.Reset}`,
+    red: (text) => `${Ansi.Red}${text}${Ansi.Reset}`,
+    gray: (text) => `${Ansi.Gray}${text}${Ansi.Reset}`,
+});
+function renderMessage(message) {
+    return `${style.cyan(Symbol.Question)} ${style.bold(message)} `;
+}
+function renderSubmitted(value) {
+    return style.cyan(value);
+}
+function renderCancelled() {
+    return style.dim('(cancelled)');
+}
+
+const PromptResult = index_cjs_js$2.freeze({
+    Submitted: 'submitted',
+    Cancelled: 'cancelled',
+});
+
+function renderOptions(initial) {
+    if (initial === true) {
+        return style.dim('(Y/n)');
+    }
+    if (initial === false) {
+        return style.dim('(y/N)');
+    }
+    return style.dim('(y/n)');
+}
+async function confirm(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    const drawPrompt = () => {
+        term.write(Ansi.CursorStart + Ansi.ClearLine);
+        term.write(renderMessage(config.message) + renderOptions(config.initial) + ' ');
+    };
+    const drawResult = (value) => {
+        term.write(Ansi.CursorStart + Ansi.ClearLine);
+        term.write(renderMessage(config.message) + renderSubmitted(value ? 'Yes' : 'No') + '\n');
+    };
+    drawPrompt();
+    while (true) {
+        const key = await term.readKey();
+        const lowerKey = key.toLowerCase();
+        if (term.isCancelled()) {
+            term.write(Ansi.CursorStart + Ansi.ClearLine);
+            term.write(renderMessage(config.message) + renderCancelled() + '\n');
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (lowerKey === 'y') {
+            drawResult(true);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Submitted, value: true });
+        }
+        if (lowerKey === 'n') {
+            drawResult(false);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Submitted, value: false });
+        }
+        if (key === Key.Enter && config.initial !== undefined) {
+            drawResult(config.initial);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Submitted, value: config.initial });
+        }
+    }
+}
+
+function arrayIncludes(arr, value) {
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i] === value)
+            return true;
+    }
+    return false;
+}
+function filterChoices$1(choices, query) {
+    if (!query) {
+        return choices.map((_, i) => i);
+    }
+    const lowerQuery = query.toLowerCase();
+    const indices = [];
+    choices.forEach((choice, i) => {
+        if (choice.label.toLowerCase().includes(lowerQuery)) {
+            indices.push(i);
+        }
+    });
+    return index_cjs_js$2.freeze(indices);
+}
+function createInitialState$2(config) {
+    return index_cjs_js$2.freeze({
+        cursor: 0,
+        selected: config.initial ? [...config.initial] : [],
+        choices: config.choices,
+        filteredIndices: config.choices.map((_, i) => i),
+        searchQuery: '',
+        scrollOffset: 0,
+    });
+}
+function getVisibleChoices$1(state, maxVisible) {
+    const total = state.filteredIndices.length;
+    if (total <= maxVisible) {
+        return { indices: state.filteredIndices, startIndex: 0 };
+    }
+    let startIndex = state.scrollOffset;
+    if (state.cursor < startIndex) {
+        startIndex = state.cursor;
+    }
+    else if (state.cursor >= startIndex + maxVisible) {
+        startIndex = state.cursor - maxVisible + 1;
+    }
+    return {
+        indices: state.filteredIndices.slice(startIndex, startIndex + maxVisible),
+        startIndex,
+    };
+}
+function renderChoice$1(choice, isSelected, isFocused) {
+    const pointer = isFocused ? style.cyan(Symbol.Pointer) : ' ';
+    const checkbox = isSelected ? style.green(Symbol.CheckboxSelected) : style.dim(Symbol.Checkbox);
+    let label = choice.label;
+    if (choice.disabled) {
+        label = style.dim(label + ' (disabled)');
+    }
+    else if (isFocused) {
+        label = isSelected ? style.green(label) : style.cyan(label);
+    }
+    else if (isSelected) {
+        label = style.green(label);
+    }
+    const hint = choice.hint ? style.dim(` — ${choice.hint}`) : '';
+    return `${pointer} ${checkbox} ${label}${hint}`;
+}
+function render$2(term, config, state, submitted) {
+    const maxVisible = config.maxVisible ?? 10;
+    const { indices: visibleIndices, startIndex } = getVisibleChoices$1(state, maxVisible);
+    let output = Ansi.CursorStart + Ansi.ClearLine + renderMessage(config.message);
+    if (submitted) {
+        const selectedLabels = state.selected.map((i) => state.choices[i]?.label ?? '').join(', ');
+        output += renderSubmitted(selectedLabels || 'none');
+        term.write(output);
+        return 1;
+    }
+    if (config.searchable && state.searchQuery) {
+        output += style.cyan(state.searchQuery) + style.dim(' (type to filter)');
+    }
+    else if (config.searchable) {
+        output += style.dim('(type to filter, space to toggle, enter to submit)');
+    }
+    else {
+        output += style.dim('(space to toggle, enter to submit)');
+    }
+    term.write(output + '\n');
+    let lineCount = 1;
+    const minMax = [];
+    if (config.min !== undefined)
+        minMax.push(`min: ${config.min}`);
+    if (config.max !== undefined)
+        minMax.push(`max: ${config.max}`);
+    const countHint = minMax.length > 0 ? ` (${minMax.join(', ')})` : '';
+    term.write(Ansi.ClearLine + style.dim(`  ${state.selected.length} selected${countHint}`) + '\n');
+    lineCount++;
+    const showScrollUp = startIndex > 0;
+    const showScrollDown = startIndex + maxVisible < state.filteredIndices.length;
+    if (showScrollUp) {
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${startIndex} more above)`) + '\n');
+        lineCount++;
+    }
+    visibleIndices.forEach((actualIndex, i) => {
+        const choice = state.choices[actualIndex];
+        /* istanbul ignore if -- @preserve defensive: actualIndex always valid from filteredIndices */
+        if (!choice)
+            return;
+        const viewIndex = startIndex + i;
+        const isFocused = viewIndex === state.cursor;
+        const isSelected = arrayIncludes(state.selected, actualIndex);
+        const line = renderChoice$1(choice, isSelected, isFocused);
+        term.write(Ansi.ClearLine + line + '\n');
+        lineCount++;
+    });
+    if (showScrollDown) {
+        const remaining = state.filteredIndices.length - (startIndex + maxVisible);
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${remaining} more below)`) + '\n');
+        lineCount++;
+    }
+    if (state.filteredIndices.length === 0 && config.searchable) {
+        term.write(Ansi.ClearLine + style.dim('  No matches found') + '\n');
+        lineCount++;
+    }
+    return lineCount;
+}
+function processKey$2(key, state, config) {
+    const maxVisible = config.maxVisible ?? 10;
+    const total = state.filteredIndices.length;
+    if (total === 0 && key !== Key.Backspace && key !== '\b')
+        return state;
+    if (key === Key.Up) {
+        let newCursor = state.cursor - 1;
+        while (newCursor >= 0 && state.choices[state.filteredIndices[newCursor] ?? -1]?.disabled) {
+            newCursor--;
+        }
+        if (newCursor < 0)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor < state.scrollOffset) {
+            newScrollOffset = newCursor;
+        }
+        return index_cjs_js$2.freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (key === Key.Down) {
+        let newCursor = state.cursor + 1;
+        while (newCursor < total && state.choices[state.filteredIndices[newCursor] ?? -1]?.disabled) {
+            newCursor++;
+        }
+        if (newCursor >= total)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor >= state.scrollOffset + maxVisible) {
+            newScrollOffset = newCursor - maxVisible + 1;
+        }
+        return index_cjs_js$2.freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (key === Key.Space) {
+        const actualIndex = state.filteredIndices[state.cursor];
+        if (actualIndex === undefined)
+            return state;
+        const choice = state.choices[actualIndex];
+        /* istanbul ignore if -- @preserve defensive: actualIndex validated above */
+        if (!choice || choice.disabled)
+            return state;
+        const isSelected = arrayIncludes(state.selected, actualIndex);
+        if (isSelected) {
+            const newSelected = state.selected.filter((i) => i !== actualIndex);
+            return index_cjs_js$2.freeze({ ...state, selected: newSelected });
+        }
+        else {
+            if (config.max !== undefined && state.selected.length >= config.max) {
+                return state;
+            }
+            const newSelected = [...state.selected, actualIndex];
+            return index_cjs_js$2.freeze({ ...state, selected: newSelected });
+        }
+    }
+    if (config.searchable) {
+        if (key === Key.Backspace || key === '\b') {
+            if (state.searchQuery.length > 0) {
+                const newQuery = state.searchQuery.slice(0, -1);
+                const newFiltered = filterChoices$1(state.choices, newQuery);
+                return index_cjs_js$2.freeze({
+                    ...state,
+                    searchQuery: newQuery,
+                    filteredIndices: newFiltered,
+                    cursor: 0,
+                    scrollOffset: 0,
+                });
+            }
+            return state;
+        }
+        if (key.length === 1 && key >= ' ' && key !== Key.Space) {
+            const newQuery = state.searchQuery + key;
+            const newFiltered = filterChoices$1(state.choices, newQuery);
+            return index_cjs_js$2.freeze({
+                ...state,
+                searchQuery: newQuery,
+                filteredIndices: newFiltered,
+                cursor: 0,
+                scrollOffset: 0,
+            });
+        }
+    }
+    return state;
+}
+function validateSelection(state, config) {
+    if (config.min !== undefined && state.selected.length < config.min) {
+        return `Select at least ${config.min} option${config.min === 1 ? '' : 's'}`;
+    }
+    if (config.max !== undefined && state.selected.length > config.max) {
+        return `Select at most ${config.max} option${config.max === 1 ? '' : 's'}`;
+    }
+    return undefined;
+}
+async function multiselect(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    let state = createInitialState$2(config);
+    let lineCount = 0;
+    let errorMessage;
+    term.write(Ansi.HideCursor);
+    const redraw = (submitted = false) => {
+        if (lineCount > 0) {
+            term.write(Ansi.cursorUp(lineCount) + Ansi.CursorStart);
+        }
+        term.write(Ansi.ClearToEnd);
+        lineCount = render$2(term, config, state, submitted);
+        if (errorMessage && !submitted) {
+            term.write(Ansi.ClearLine + style.yellow(`  ${errorMessage}`) + '\n');
+            lineCount++;
+        }
+    };
+    redraw();
+    while (true) {
+        const key = await term.readKey();
+        if (term.isCancelled()) {
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            term.write(renderMessage(config.message) + renderCancelled() + '\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (key === Key.Enter) {
+            const validationError = validateSelection(state, config);
+            if (validationError) {
+                errorMessage = validationError;
+                redraw();
+                continue;
+            }
+            const selectedValues = state.selected.map((i) => state.choices[i]?.value).filter((v) => v !== undefined);
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            render$2(term, config, state, true);
+            term.write('\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Submitted, value: index_cjs_js$2.freeze(selectedValues) });
+        }
+        errorMessage = undefined;
+        state = processKey$2(key, state, config);
+        redraw();
+    }
+}
+
+function filterChoices(choices, query) {
+    if (!query) {
+        return choices.map((_, i) => i);
+    }
+    const lowerQuery = query.toLowerCase();
+    const indices = [];
+    choices.forEach((choice, i) => {
+        if (choice.label.toLowerCase().includes(lowerQuery)) {
+            indices.push(i);
+        }
+    });
+    return index_cjs_js$2.freeze(indices);
+}
+function createInitialState$1(config) {
+    return index_cjs_js$2.freeze({
+        cursor: config.initial ?? 0,
+        choices: config.choices,
+        filteredIndices: config.choices.map((_, i) => i),
+        searchQuery: '',
+        scrollOffset: 0,
+    });
+}
+function getVisibleChoices(state, maxVisible) {
+    const total = state.filteredIndices.length;
+    if (total <= maxVisible) {
+        return { indices: state.filteredIndices, startIndex: 0 };
+    }
+    let startIndex = state.scrollOffset;
+    if (state.cursor < startIndex) {
+        startIndex = state.cursor;
+    }
+    else if (state.cursor >= startIndex + maxVisible) {
+        startIndex = state.cursor - maxVisible + 1;
+    }
+    return {
+        indices: state.filteredIndices.slice(startIndex, startIndex + maxVisible),
+        startIndex,
+    };
+}
+function renderChoice(choice, isFocused) {
+    const pointer = isFocused ? style.cyan(Symbol.Pointer) : ' ';
+    let label = choice.label;
+    if (choice.disabled) {
+        label = style.dim(label + ' (disabled)');
+    }
+    else if (isFocused) {
+        label = style.cyan(label);
+    }
+    const hint = choice.hint ? style.dim(` — ${choice.hint}`) : '';
+    return `${pointer} ${label}${hint}`;
+}
+function render$1(term, config, state, submitted) {
+    const maxVisible = config.maxVisible ?? 10;
+    const { indices: visibleIndices, startIndex } = getVisibleChoices(state, maxVisible);
+    let output = Ansi.CursorStart + Ansi.ClearLine + renderMessage(config.message);
+    if (submitted) {
+        const actualIndex = state.filteredIndices[state.cursor];
+        const selectedChoice = actualIndex !== undefined ? state.choices[actualIndex] : undefined;
+        /* istanbul ignore next -- @preserve defensive: cursor always within bounds */
+        output += renderSubmitted(selectedChoice?.label ?? '');
+        term.write(output);
+        return 1;
+    }
+    if (config.searchable && state.searchQuery) {
+        output += style.cyan(state.searchQuery) + style.dim(' (type to filter)');
+    }
+    else if (config.searchable) {
+        output += style.dim('(type to filter, enter to select)');
+    }
+    else {
+        output += style.dim('(use arrows, enter to select)');
+    }
+    term.write(output + '\n');
+    let lineCount = 1;
+    const showScrollUp = startIndex > 0;
+    const showScrollDown = startIndex + maxVisible < state.filteredIndices.length;
+    if (showScrollUp) {
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${startIndex} more above)`) + '\n');
+        lineCount++;
+    }
+    visibleIndices.forEach((actualIndex, i) => {
+        const choice = state.choices[actualIndex];
+        /* istanbul ignore if -- @preserve defensive: actualIndex always valid from filteredIndices */
+        if (!choice)
+            return;
+        const viewIndex = startIndex + i;
+        const isFocused = viewIndex === state.cursor;
+        const line = renderChoice(choice, isFocused);
+        term.write(Ansi.ClearLine + line + '\n');
+        lineCount++;
+    });
+    if (showScrollDown) {
+        const remaining = state.filteredIndices.length - (startIndex + maxVisible);
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${remaining} more below)`) + '\n');
+        lineCount++;
+    }
+    if (state.filteredIndices.length === 0 && config.searchable) {
+        term.write(Ansi.ClearLine + style.dim('  No matches found') + '\n');
+        lineCount++;
+    }
+    return lineCount;
+}
+function processKey$1(key, state, config) {
+    const maxVisible = config.maxVisible ?? 10;
+    const total = state.filteredIndices.length;
+    if (total === 0 && key !== Key.Backspace && key !== '\b')
+        return state;
+    if (key === Key.Up) {
+        let newCursor = state.cursor - 1;
+        while (newCursor >= 0 && state.choices[state.filteredIndices[newCursor] ?? -1]?.disabled) {
+            newCursor--;
+        }
+        if (newCursor < 0)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor < state.scrollOffset) {
+            newScrollOffset = newCursor;
+        }
+        return index_cjs_js$2.freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (key === Key.Down) {
+        let newCursor = state.cursor + 1;
+        while (newCursor < total && state.choices[state.filteredIndices[newCursor] ?? -1]?.disabled) {
+            newCursor++;
+        }
+        if (newCursor >= total)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor >= state.scrollOffset + maxVisible) {
+            newScrollOffset = newCursor - maxVisible + 1;
+        }
+        return index_cjs_js$2.freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (config.searchable) {
+        if (key === Key.Backspace || key === '\b') {
+            if (state.searchQuery.length > 0) {
+                const newQuery = state.searchQuery.slice(0, -1);
+                const newFiltered = filterChoices(state.choices, newQuery);
+                return index_cjs_js$2.freeze({
+                    ...state,
+                    searchQuery: newQuery,
+                    filteredIndices: newFiltered,
+                    cursor: 0,
+                    scrollOffset: 0,
+                });
+            }
+            return state;
+        }
+        if (key.length === 1 && key >= ' ') {
+            const newQuery = state.searchQuery + key;
+            const newFiltered = filterChoices(state.choices, newQuery);
+            return index_cjs_js$2.freeze({
+                ...state,
+                searchQuery: newQuery,
+                filteredIndices: newFiltered,
+                cursor: 0,
+                scrollOffset: 0,
+            });
+        }
+    }
+    return state;
+}
+async function select(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    let state = createInitialState$1(config);
+    let lineCount = 0;
+    term.write(Ansi.HideCursor);
+    const redraw = (submitted = false) => {
+        if (lineCount > 0) {
+            term.write(Ansi.cursorUp(lineCount) + Ansi.CursorStart);
+        }
+        term.write(Ansi.ClearToEnd);
+        lineCount = render$1(term, config, state, submitted);
+    };
+    redraw();
+    while (true) {
+        const key = await term.readKey();
+        if (term.isCancelled()) {
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            term.write(renderMessage(config.message) + renderCancelled() + '\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (key === Key.Enter) {
+            const actualIndex = state.filteredIndices[state.cursor];
+            if (actualIndex === undefined) {
+                continue;
+            }
+            const selectedChoice = state.choices[actualIndex];
+            if (!selectedChoice || selectedChoice.disabled) {
+                continue;
+            }
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            render$1(term, config, state, true);
+            term.write('\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Submitted, value: selectedChoice.value });
+        }
+        state = processKey$1(key, state, config);
+        redraw();
+    }
+}
+
+function createInitialState(config) {
+    return {
+        value: config.initial ?? '',
+        cursorPos: (config.initial ?? '').length,
+        error: undefined,
+    };
+}
+function render(term, config, state, submitted) {
+    const displayValue = config.format ? config.format(state.value) : state.value;
+    const messageText = config.renderMessage ? config.renderMessage(state.value) : config.message;
+    let output = renderMessage(messageText);
+    let trailingChars = 0;
+    if (submitted) {
+        output += renderSubmitted(displayValue || config.initial || '');
+    }
+    else {
+        output += displayValue;
+        trailingChars = displayValue.length - state.cursorPos;
+        if (config.initial && !state.value) {
+            output += style.dim(config.initial);
+            trailingChars += config.initial.length;
+        }
+    }
+    term.write(Ansi.CursorStart + Ansi.ClearLine + output);
+    if (state.error) {
+        term.write('\n' + style.yellow(`  ${state.error}`));
+        return 2;
+    }
+    if (!submitted && trailingChars > 0) {
+        term.write(Ansi.cursorLeft(trailingChars));
+    }
+    return 1;
+}
+function processKey(key, state) {
+    if (key.length === 1 && key >= ' ' && key !== Key.Backspace) {
+        const before = state.value.slice(0, state.cursorPos);
+        const after = state.value.slice(state.cursorPos);
+        return {
+            ...state,
+            value: before + key + after,
+            cursorPos: state.cursorPos + 1,
+            error: undefined,
+        };
+    }
+    if (key === Key.Backspace || key === '\b') {
+        if (state.cursorPos > 0) {
+            const before = state.value.slice(0, state.cursorPos - 1);
+            const after = state.value.slice(state.cursorPos);
+            return {
+                ...state,
+                value: before + after,
+                cursorPos: state.cursorPos - 1,
+                error: undefined,
+            };
+        }
+    }
+    if (key === Key.Left) {
+        return {
+            ...state,
+            cursorPos: index_cjs_js$4.max(0, state.cursorPos - 1),
+        };
+    }
+    if (key === Key.Right) {
+        return {
+            ...state,
+            cursorPos: index_cjs_js$4.min(state.value.length, state.cursorPos + 1),
+        };
+    }
+    return state;
+}
+async function text(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    let state = createInitialState(config);
+    let lineCount = 0;
+    const redraw = (submitted = false) => {
+        if (lineCount > 0) {
+            term.clearLines(lineCount);
+        }
+        lineCount = render(term, config, state, submitted);
+    };
+    redraw();
+    while (true) {
+        const key = await term.readKey();
+        if (term.isCancelled()) {
+            redraw();
+            term.write(renderCancelled() + '\n');
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (key === Key.Enter) {
+            const value = state.value || config.initial || '';
+            if (config.validate) {
+                const errorMessage = config.validate(value);
+                if (errorMessage) {
+                    state = { ...state, error: errorMessage };
+                    redraw();
+                    continue;
+                }
+            }
+            redraw(true);
+            term.write('\n');
+            term.close();
+            return index_cjs_js$2.freeze({ result: PromptResult.Submitted, value });
+        }
+        state = processKey(key, state);
+        redraw();
+    }
+}
+
+function omitKeys(source, keys) {
+    const dropSet = index_cjs_js$5.createSet(keys);
+    return index_cjs_js$2.fromEntries(index_cjs_js$2.entries(source).filter(([key]) => !dropSet.has(key)));
+}
+
+const bodyStep = {
+    id: 'body',
+    async run(ctx) {
+        const outcome = await text({
+            message: 'Body (optional, press Enter to skip):',
+            ...(ctx.draft.body && { initial: ctx.draft.body }),
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (outcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        const trimmed = outcome.value.trim();
+        ctx.draft = trimmed === '' ? omitBody(ctx) : { ...ctx.draft, body: trimmed };
+        return done();
+    },
+};
+function omitBody(ctx) {
+    return omitKeys(ctx.draft, ['body']);
+}
+
+function replaceChar(input, target, replacement) {
+    const result = [];
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (char !== undefined)
+            result.push(char === target ? replacement : char);
+    }
+    return result.join('');
+}
+function hyphenToSpace(input) {
+    return replaceChar(input, '-', ' ');
+}
+function isBreakingFooterKey(key) {
+    const normalized = hyphenToSpace(key.toUpperCase());
+    return normalized === 'BREAKING CHANGE';
+}
+
+const breakingStep = {
+    id: 'breaking',
+    async run(ctx) {
+        const confirmOutcome = await confirm({
+            message: 'Is this a breaking change?',
+            initial: ctx.draft.breaking ?? false,
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (confirmOutcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        if (!confirmOutcome.value) {
+            ctx.draft = clearBreaking(ctx.draft);
+            return done();
+        }
+        const descriptionOutcome = await text({
+            message: 'Describe the breaking change:',
+            ...(ctx.draft.breakingDescription && { initial: ctx.draft.breakingDescription }),
+            validate: (value) => (value.trim() === '' ? 'Description must not be empty' : undefined),
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (descriptionOutcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        ctx.draft = {
+            ...ctx.draft,
+            breaking: true,
+            breakingDescription: descriptionOutcome.value.trim(),
+        };
+        return done();
+    },
+};
+function clearBreaking(draft) {
+    const rest = omitKeys(draft, ['breaking', 'breakingDescription', 'footers']);
+    if (!draft.footers)
+        return { ...rest, breaking: false };
+    const filtered = draft.footers.filter((footer) => !isBreakingFooterKey(footer.key));
+    return {
+        ...rest,
+        breaking: false,
+        ...(filtered.length > 0 && { footers: filtered }),
+    };
+}
+
+function createGitCommit(options) {
+    const body = options.body ?? '';
+    const subject = options.subject;
+    return {
+        hash: options.hash,
+        shortHash: getShortHash(options.hash),
+        authorName: options.authorName,
+        authorEmail: options.authorEmail,
+        authorDate: options.authorDate,
+        committerName: options.committerName ?? options.authorName,
+        committerEmail: options.committerEmail ?? options.authorEmail,
+        commitDate: options.commitDate ?? options.authorDate,
+        subject,
+        body,
+        message: body ? `${subject}\n\n${body}` : subject,
+        parents: options.parents ?? [],
+        refs: options.refs ?? [],
+    };
+}
+function getShortHash(hash) {
+    return hash.slice(0, 7);
+}
+
+const DEFAULT_LOG_OPTIONS = {
+    maxCount: 100,
+    includeMerges: true,
+    timeout: 30000,
+};
+const LOG_FORMAT = ['%H', '%an', '%ae', '%aI', '%cn', '%ce', '%cI', '%s', '%b', '%P', '%D'].join('%x00');
+const RECORD_SEPARATOR = '\x1e';
+function getCommitLog(options = {}) {
+    const opts = { ...DEFAULT_LOG_OPTIONS, ...options };
+    const args = ['log', `--format=${RECORD_SEPARATOR}${LOG_FORMAT}`];
+    if (opts.maxCount !== undefined && opts.maxCount > 0) {
+        args.push(`-n${opts.maxCount}`);
+    }
+    if (!opts.includeMerges) {
+        args.push('--no-merges');
+    }
+    if (opts.author) {
+        const safeAuthor = escapeGitArg(opts.author);
+        args.push(`--author=${safeAuthor}`);
+    }
+    if (opts.from && opts.to) {
+        const safeFrom = escapeGitRef(opts.from);
+        const safeTo = escapeGitRef(opts.to);
+        args.push(`${safeFrom}..${safeTo}`);
+    }
+    else if (opts.from) {
+        const safeFrom = escapeGitRef(opts.from);
+        args.push(`${safeFrom}..HEAD`);
+    }
+    else if (opts.to) {
+        const safeTo = escapeGitRef(opts.to);
+        args.push(safeTo);
+    }
+    if (opts.path) {
+        const safePath = escapeGitPath(opts.path);
+        args.push('--', safePath);
+    }
+    try {
+        const output = node_child_process.execFileSync('git', args, {
+            encoding: 'utf-8',
+            cwd: opts.cwd,
+            timeout: opts.timeout,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 50 * 1024 * 1024,
+        });
+        return parseCommitLog(output);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('does not have any commits')) {
+            return [];
+        }
+        throw error;
+    }
+}
+function getCommit(hash, options = {}) {
+    const safeHash = escapeGitRef(hash);
+    try {
+        const commits = getCommitLog({
+            ...options,
+            to: safeHash,
+            maxCount: 1,
+        });
+        return commits[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseCommitLog(output) {
+    const commits = [];
+    if (!output.trim()) {
+        return commits;
+    }
+    const records = splitByDelimiter(output, RECORD_SEPARATOR);
+    for (const record of records) {
+        const trimmed = record.trim();
+        if (!trimmed)
+            continue;
+        const fields = splitByDelimiter(trimmed, '\x00');
+        if (fields.length < 10)
+            continue;
+        const [hash, authorName, authorEmail, authorDate, committerName, committerEmail, commitDate, subject, body, parentsStr, refsStr] = fields;
+        const parents = parentsStr ? splitByDelimiter(parentsStr, ' ').filter((p) => p.trim()) : [];
+        const refs = parseRefs(refsStr || '');
+        commits.push(createGitCommit({
+            hash,
+            authorName,
+            authorEmail,
+            authorDate,
+            committerName,
+            committerEmail,
+            commitDate,
+            subject,
+            body: body || undefined,
+            parents,
+            refs,
+        }));
+    }
+    return commits;
+}
+function parseRefs(refsStr) {
+    if (!refsStr.trim()) {
+        return [];
+    }
+    const refs = [];
+    const parts = splitByDelimiter(refsStr, ',');
+    for (const part of parts) {
+        let ref = part.trim();
+        const arrowIndex = findSubstring(ref, ' -> ');
+        if (arrowIndex !== -1) {
+            refs.push('HEAD');
+            ref = ref.slice(arrowIndex + 4);
+        }
+        if (startsWithPrefix(ref, 'tag: ')) {
+            ref = ref.slice(5);
+        }
+        if (ref) {
+            refs.push(ref);
+        }
+    }
+    return refs;
+}
+function splitByDelimiter(str, delimiter) {
+    const parts = [];
+    let current = '';
+    let i = 0;
+    while (i < str.length) {
+        if (matchesAt(str, i, delimiter)) {
+            parts.push(current);
+            current = '';
+            i += delimiter.length;
+        }
+        else {
+            current += str[i];
+            i++;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+function matchesAt(str, pos, pattern) {
+    if (pos + pattern.length > str.length)
+        return false;
+    for (let i = 0; i < pattern.length; i++) {
+        if (str[pos + i] !== pattern[i])
+            return false;
+    }
+    return true;
+}
+function findSubstring(str, pattern) {
+    for (let i = 0; i <= str.length - pattern.length; i++) {
+        if (matchesAt(str, i, pattern)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function startsWithPrefix(str, prefix) {
+    return matchesAt(str, 0, prefix);
+}
+const MAX_REF_LENGTH = 256;
+function escapeGitRef(ref) {
+    if (!ref || typeof ref !== 'string') {
+        throw index_cjs_js.createError('Git reference is required');
+    }
+    if (ref.length > MAX_REF_LENGTH) {
+        throw index_cjs_js.createError(`Git reference exceeds maximum length of ${MAX_REF_LENGTH}`);
+    }
+    const safe = [];
+    for (let i = 0; i < ref.length; i++) {
+        const code = ref.charCodeAt(i);
+        if ((code >= 97 && code <= 122) ||
+            (code >= 65 && code <= 90) ||
+            (code >= 48 && code <= 57) ||
+            code === 47 ||
+            code === 45 ||
+            code === 95 ||
+            code === 46 ||
+            code === 126 ||
+            code === 94 ||
+            code === 64 ||
+            code === 123 ||
+            code === 125) {
+            safe.push(ref[i]);
+        }
+        else {
+            throw index_cjs_js.createError(`Invalid character in git reference at position ${i}: "${ref[i]}"`);
+        }
+    }
+    return safe.join('');
+}
+const MAX_PATH_LENGTH$1 = 4096;
+function escapeGitPath(path) {
+    if (!path || typeof path !== 'string') {
+        throw index_cjs_js.createError('Path is required');
+    }
+    if (path.length > MAX_PATH_LENGTH$1) {
+        throw index_cjs_js.createError(`Path exceeds maximum length of ${MAX_PATH_LENGTH$1}`);
+    }
+    const safe = [];
+    for (let i = 0; i < path.length; i++) {
+        const code = path.charCodeAt(i);
+        if ((code >= 97 && code <= 122) ||
+            (code >= 65 && code <= 90) ||
+            (code >= 48 && code <= 57) ||
+            code === 47 ||
+            code === 92 ||
+            code === 45 ||
+            code === 95 ||
+            code === 46 ||
+            code === 32) {
+            safe.push(path[i]);
+        }
+        else {
+            throw index_cjs_js.createError(`Invalid character in path at position ${i}: "${path[i]}"`);
+        }
+    }
+    return safe.join('');
+}
+const MAX_ARG_LENGTH = 1000;
+function escapeGitArg(arg) {
+    if (!arg || typeof arg !== 'string') {
+        throw index_cjs_js.createError('Argument is required');
+    }
+    if (arg.length > MAX_ARG_LENGTH) {
+        throw index_cjs_js.createError(`Argument exceeds maximum length of ${MAX_ARG_LENGTH}`);
+    }
+    const safe = [];
+    for (let i = 0; i < arg.length; i++) {
+        const code = arg.charCodeAt(i);
+        if ((code >= 97 && code <= 122) ||
+            (code >= 65 && code <= 90) ||
+            (code >= 48 && code <= 57) ||
+            code === 32 ||
+            code === 64 ||
+            code === 46 ||
+            code === 45 ||
+            code === 95 ||
+            code === 60 ||
+            code === 62 ||
+            code === 43) {
+            safe.push(arg[i]);
+        }
+        else {
+            throw index_cjs_js.createError(`Invalid character in argument at position ${i}: "${arg[i]}"`);
+        }
+    }
+    return safe.join('');
+}
+
+const MAX_MESSAGE_LENGTH$1 = 10000;
+function escapeGitMessage(message) {
+    if (!message || typeof message !== 'string') {
+        throw index_cjs_js.createError('Message is required');
+    }
+    if (message.length > MAX_MESSAGE_LENGTH$1) {
+        throw index_cjs_js.createError(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH$1}`);
+    }
+    const safe = [];
+    for (let i = 0; i < message.length; i++) {
+        const char = message[i];
+        const code = message.charCodeAt(i);
+        if (char === '"' || char === '\\') {
+            safe.push('\\');
+            safe.push(char);
+        }
+        else if ((code >= 32 && code <= 126) || code === 10 || code === 13 || code === 9) {
+            safe.push(char);
+        }
+    }
+    return safe.join('');
+}
+
+const DEFAULT_COMMIT_OPTIONS = {
+    timeout: 30000,
+};
+function commit(message, options = {}) {
+    const opts = { ...DEFAULT_COMMIT_OPTIONS, ...options };
+    const isNoEditAmend = opts.amend && opts.noEdit;
+    if (!isNoEditAmend && (!message || typeof message !== 'string')) {
+        throw index_cjs_js.createError('Commit message is required');
+    }
+    const args = ['commit'];
+    if (isNoEditAmend) {
+        args.push('--amend', '--no-edit');
+    }
+    else {
+        const safeMessage = escapeGitMessage(message);
+        let fullMessage = safeMessage;
+        if (opts.body) {
+            const safeBody = escapeGitMessage(opts.body);
+            fullMessage = `${safeMessage}\n\n${safeBody}`;
+        }
+        args.push('-m', fullMessage);
+        if (opts.amend) {
+            args.push('--amend');
+        }
+    }
+    if (opts.allowEmpty) {
+        args.push('--allow-empty');
+    }
+    if (opts.sign) {
+        args.push('-S');
+    }
+    if (opts.noVerify) {
+        args.push('--no-verify');
+    }
+    if (opts.author) {
+        const safeAuthor = escapeAuthor(opts.author);
+        args.push('--author', safeAuthor);
+    }
+    if (opts.files && opts.files.length > 0) {
+        args.push('--');
+        for (const file of opts.files) {
+            args.push(escapeFilePath(file));
+        }
+    }
+    try {
+        node_child_process.execFileSync('git', args, {
+            encoding: 'utf-8',
+            cwd: opts.cwd,
+            timeout: opts.timeout,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const commit = getCommit('HEAD', opts);
+        if (!commit) {
+            throw index_cjs_js.createError('Failed to retrieve created commit');
+        }
+        return commit;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw index_cjs_js.createError(`Failed to create commit: ${error.message}`);
+        }
+        throw error;
+    }
+}
+const MAX_PATH_LENGTH = 4096;
+function escapeFilePath(path) {
+    if (!path || typeof path !== 'string') {
+        throw index_cjs_js.createError('File path is required');
+    }
+    if (path.length > MAX_PATH_LENGTH) {
+        throw index_cjs_js.createError(`Path exceeds maximum length of ${MAX_PATH_LENGTH}`);
+    }
+    const safe = [];
+    for (let i = 0; i < path.length; i++) {
+        const code = path.charCodeAt(i);
+        if ((code >= 97 && code <= 122) ||
+            (code >= 65 && code <= 90) ||
+            (code >= 48 && code <= 57) ||
+            code === 47 ||
+            code === 92 ||
+            code === 45 ||
+            code === 95 ||
+            code === 46 ||
+            code === 32) {
+            const char = path[i];
+            if (char !== undefined)
+                safe.push(char);
+        }
+        else {
+            throw index_cjs_js.createError(`Invalid character in path at position ${i}: "${path[i]}"`);
+        }
+    }
+    return safe.join('');
+}
+const MAX_AUTHOR_LENGTH = 500;
+function escapeAuthor(author) {
+    if (!author || typeof author !== 'string') {
+        throw index_cjs_js.createError('Author is required');
+    }
+    if (author.length > MAX_AUTHOR_LENGTH) {
+        throw index_cjs_js.createError(`Author exceeds maximum length of ${MAX_AUTHOR_LENGTH}`);
+    }
+    const safe = [];
+    for (let i = 0; i < author.length; i++) {
+        const code = author.charCodeAt(i);
+        if ((code >= 97 && code <= 122) ||
+            (code >= 65 && code <= 90) ||
+            (code >= 48 && code <= 57) ||
+            code === 32 ||
+            code === 64 ||
+            code === 46 ||
+            code === 45 ||
+            code === 95 ||
+            code === 60 ||
+            code === 62) {
+            const char = author[i];
+            if (char !== undefined)
+                safe.push(char);
+        }
+        else {
+            throw index_cjs_js.createError(`Invalid character in author at position ${i}: "${author[i]}"`);
+        }
+    }
+    return safe.join('');
+}
+
+function formatHeader(draft) {
+    let header = draft.type ?? '';
+    if (draft.scope && draft.scope.length > 0) {
+        header += `(${draft.scope.join(',')})`;
+    }
+    if (draft.breaking) {
+        header += '!';
+    }
+    header += `: ${draft.subject ?? ''}`;
+    return header;
+}
+
+function formatCommitMessage(draft) {
+    const parts = [formatHeader(draft)];
+    if (draft.body && draft.body.length > 0) {
+        parts.push('');
+        parts.push(draft.body);
+    }
+    const footers = resolveFooters(draft);
+    if (footers.length > 0) {
+        parts.push('');
+        for (const footer of footers) {
+            parts.push(renderFooter(footer));
+        }
+    }
+    return parts.join('\n');
+}
+function resolveFooters(draft) {
+    const existing = draft.footers ?? [];
+    if (!draft.breaking || !draft.breakingDescription)
+        return existing;
+    if (existing.some((footer) => isBreakingFooterKey(footer.key)))
+        return existing;
+    const synthesized = {
+        key: 'BREAKING CHANGE',
+        value: draft.breakingDescription,
+        separator: ':',
+    };
+    return [synthesized, ...existing];
+}
+function renderFooter(footer) {
+    const joiner = footer.separator === ':' ? ' ' : '';
+    return `${footer.key}${footer.separator}${joiner}${footer.value}`;
+}
+
+const commitStep = {
+    id: 'commit',
+    async run(ctx) {
+        if (ctx.config.skipCommit)
+            return done();
+        const message = formatCommitMessage(ctx.draft);
+        const executor = ctx.config.commitExecutor ?? defaultCommitExecutor(ctx.config.cwd);
+        try {
+            await executor(message);
+        }
+        catch (unknown) {
+            const error = unknown instanceof Error ? unknown : index_cjs_js.createError(String(unknown));
+            return cancelled(error);
+        }
+        return done();
+    },
+};
+function defaultCommitExecutor(cwd) {
+    return (message) => {
+        commit(message, { cwd });
+    };
+}
+
+const issuesStep = {
+    id: 'issues',
+    async run(ctx) {
+        const confirmOutcome = await confirm({
+            message: 'Does this change reference any issues?',
+            initial: hasIssueFooter(ctx.draft.footers),
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (confirmOutcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        if (!confirmOutcome.value) {
+            ctx.draft = stripIssueFooters(ctx.draft);
+            return done();
+        }
+        const textOutcome = await text({
+            message: 'Issue references (e.g. fixes #123, re #456):',
+            validate: (value) => (parseReferences(value).length === 0 ? 'Enter at least one reference like "fixes #123"' : undefined),
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (textOutcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        ctx.draft = applyIssueFooters(ctx.draft, parseReferences(textOutcome.value));
+        return done();
+    },
+};
+function parseReferences(raw) {
+    const footers = [];
+    const length = raw.length;
+    let pos = 0;
+    while (pos < length) {
+        const code = raw.charCodeAt(pos);
+        if (!isLetter(code)) {
+            pos++;
+            continue;
+        }
+        const keywordStart = pos;
+        pos++;
+        while (pos < length && (isLetter(raw.charCodeAt(pos)) || raw.charCodeAt(pos) === HYPHEN)) {
+            pos++;
+        }
+        const keyword = raw.slice(keywordStart, pos);
+        while (pos < length && isWhitespace(raw.charCodeAt(pos))) {
+            pos++;
+        }
+        if (pos >= length || raw.charCodeAt(pos) !== HASH)
+            continue;
+        pos++;
+        const numberStart = pos;
+        while (pos < length && isDigit$1(raw.charCodeAt(pos))) {
+            pos++;
+        }
+        if (pos === numberStart)
+            continue;
+        footers.push({ key: capitalize(keyword), value: raw.slice(numberStart, pos), separator: ' #' });
+    }
+    return footers;
+}
+const HASH = 35;
+const HYPHEN = 45;
+function isDigit$1(code) {
+    return code >= 48 && code <= 57;
+}
+function isLetter(code) {
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function isWhitespace(code) {
+    return code === 32 || code === 9 || code === 10 || code === 13;
+}
+function hasIssueFooter(footers) {
+    if (!footers)
+        return false;
+    return footers.some((footer) => footer.separator === ' #');
+}
+function applyIssueFooters(draft, newIssueFooters) {
+    const preserved = (draft.footers ?? []).filter((footer) => footer.separator !== ' #');
+    return { ...draft, footers: [...preserved, ...newIssueFooters] };
+}
+function stripIssueFooters(draft) {
+    if (!draft.footers)
+        return draft;
+    const preserved = draft.footers.filter((footer) => footer.separator !== ' #');
+    if (preserved.length === draft.footers.length)
+        return draft;
+    if (preserved.length === 0)
+        return omitKeys(draft, ['footers']);
+    return { ...draft, footers: preserved };
+}
+function capitalize(keyword) {
+    const first = keyword.charAt(0).toUpperCase();
+    return first + keyword.slice(1).toLowerCase();
+}
+
+function parseBody(lines, startIndex) {
+    let pos = startIndex;
+    while (pos < lines.length) {
+        const currentLine = lines[pos];
+        if (currentLine === undefined || currentLine.trim() !== '')
+            break;
+        pos++;
+    }
+    if (pos >= lines.length) {
+        return undefined;
+    }
+    const firstLine = lines[pos];
+    if (firstLine === undefined || isFooterLine(firstLine)) {
+        return undefined;
+    }
+    const bodyLines = [];
+    while (pos < lines.length) {
+        const line = lines[pos];
+        if (line === undefined)
+            break;
+        if (isFooterLine(line)) {
+            break;
+        }
+        const nextLine = lines[pos + 1];
+        if (line.trim() === '' && pos + 1 < lines.length && nextLine !== undefined && isFooterLine(nextLine)) {
+            break;
+        }
+        bodyLines.push(line);
+        pos++;
+    }
+    while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1]?.trim() === '') {
+        bodyLines.pop();
+    }
+    if (bodyLines.length === 0) {
+        return undefined;
+    }
+    return {
+        body: bodyLines.join('\n'),
+        endIndex: pos,
+    };
+}
+function isFooterLine(line) {
+    if (!line)
+        return false;
+    const trimmed = line.trim();
+    if (trimmed === '')
+        return false;
+    if (trimmed.startsWith('BREAKING CHANGE:') || trimmed.startsWith('BREAKING-CHANGE:')) {
+        return true;
+    }
+    let pos = 0;
+    while (pos < trimmed.length && trimmed[pos] === ' ') {
+        pos++;
+    }
+    const tokenStart = pos;
+    while (pos < trimmed.length) {
+        const code = trimmed.charCodeAt(pos);
+        if ((code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) || code === 45) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    if (pos === tokenStart)
+        return false;
+    if (trimmed[pos] === ':') {
+        return true;
+    }
+    if (trimmed[pos] === ' ' && trimmed[pos + 1] === '#') {
+        return true;
+    }
+    return false;
+}
+
+function parseFooters(lines, startIndex) {
+    const footers = [];
+    let breakingDescription;
+    let pos = startIndex;
+    while (pos < lines.length) {
+        const currentLine = lines[pos];
+        if (currentLine === undefined || currentLine.trim() !== '')
+            break;
+        pos++;
+    }
+    while (pos < lines.length) {
+        const line = lines[pos];
+        if (line === undefined) {
+            pos++;
+            continue;
+        }
+        const footer = parseFooterLine(line);
+        if (footer) {
+            footers.push(footer);
+            if (isBreakingFooterKey(footer.key)) {
+                breakingDescription = footer.value;
+                pos++;
+                while (pos < lines.length) {
+                    const nextLineCheck = lines[pos];
+                    if (nextLineCheck === undefined || isNewFooter(nextLineCheck))
+                        break;
+                    const nextLine = nextLineCheck;
+                    if (nextLine.trim() !== '') {
+                        breakingDescription += '\n' + nextLine;
+                    }
+                    pos++;
+                }
+                continue;
+            }
+        }
+        pos++;
+    }
+    return { footers, breakingDescription };
+}
+function parseFooterLine(line) {
+    if (!line)
+        return null;
+    const trimmed = line.trim();
+    if (trimmed === '')
+        return null;
+    if (trimmed.startsWith('BREAKING CHANGE:')) {
+        return {
+            key: 'BREAKING CHANGE',
+            value: trimmed.slice(16).trim(),
+            separator: ':',
+        };
+    }
+    if (trimmed.startsWith('BREAKING-CHANGE:')) {
+        return {
+            key: 'BREAKING-CHANGE',
+            value: trimmed.slice(16).trim(),
+            separator: ':',
+        };
+    }
+    let pos = 0;
+    const tokenStart = pos;
+    while (pos < trimmed.length) {
+        const code = trimmed.charCodeAt(pos);
+        if ((code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) || code === 45) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    if (pos === tokenStart)
+        return null;
+    const key = trimmed.slice(tokenStart, pos);
+    let separator;
+    let valueStart;
+    if (trimmed[pos] === ':') {
+        separator = ':';
+        valueStart = pos + 1;
+    }
+    else if (trimmed[pos] === ' ' && trimmed[pos + 1] === '#') {
+        separator = ' #';
+        valueStart = pos + 2;
+    }
+    else {
+        return null;
+    }
+    if (separator === ':') {
+        while (valueStart < trimmed.length && trimmed[valueStart] === ' ') {
+            valueStart++;
+        }
+    }
+    const value = trimmed.slice(valueStart);
+    return { key, value, separator };
+}
+function isNewFooter(line) {
+    if (!line)
+        return false;
+    return parseFooterLine(line) !== null;
+}
+
+function parseHeader(line) {
+    let pos = 0;
+    const len = line.length;
+    const typeStart = pos;
+    while (pos < len) {
+        const code = line.charCodeAt(pos);
+        if ((code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57)) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    const type = line.slice(typeStart, pos).toLowerCase();
+    let scope = [];
+    if (line[pos] === '(') {
+        pos++;
+        const scopeStart = pos;
+        while (pos < len && line[pos] !== ')') {
+            pos++;
+        }
+        scope = splitScopes(line.slice(scopeStart, pos));
+        if (line[pos] === ')') {
+            pos++;
+        }
+    }
+    const breaking = line[pos] === '!';
+    if (breaking) {
+        pos++;
+    }
+    if (line[pos] === ':') {
+        pos++;
+    }
+    while (pos < len && line[pos] === ' ') {
+        pos++;
+    }
+    const subject = line.slice(pos).trim();
+    return {
+        type,
+        scope,
+        subject,
+        breaking,
+    };
+}
+function splitScopes(raw) {
+    if (raw === '') {
+        return [''];
+    }
+    return raw.split(',').map((s) => s.trim());
+}
+
+const MAX_MESSAGE_LENGTH = 10 * 1024;
+function parseConventionalCommit(message) {
+    if (message.length > MAX_MESSAGE_LENGTH) {
+        throw index_cjs_js.createError(`Commit message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
+    }
+    const lines = splitLines(message);
+    if (lines.length === 0) {
+        return {
+            type: '',
+            scope: [],
+            subject: '',
+            footers: [],
+            breaking: false,
+            raw: message,
+        };
+    }
+    const firstLine = lines[0];
+    if (firstLine === undefined) {
+        return {
+            type: '',
+            scope: [],
+            subject: '',
+            footers: [],
+            breaking: false,
+            raw: message,
+        };
+    }
+    const header = parseHeader(firstLine);
+    let body;
+    let footersStartIndex = 1;
+    if (lines.length > 1) {
+        const bodyResult = parseBody(lines, 1);
+        if (bodyResult) {
+            body = bodyResult.body;
+            footersStartIndex = bodyResult.endIndex;
+        }
+    }
+    const footersResult = parseFooters(lines, footersStartIndex);
+    const breakingDescriptionFromFooter = footersResult.breakingDescription;
+    const breaking = header.breaking || footersResult.footers.some((f) => hyphenToSpace(f.key.toUpperCase()) === 'BREAKING CHANGE');
+    let breakingDescription;
+    if (header.breaking && header.subject) {
+        breakingDescription = header.subject;
+    }
+    if (breakingDescriptionFromFooter) {
+        breakingDescription = breakingDescriptionFromFooter;
+    }
+    return {
+        type: header.type,
+        scope: header.scope,
+        subject: header.subject,
+        body,
+        footers: footersResult.footers,
+        breaking,
+        breakingDescription,
+        raw: message,
+    };
+}
+function splitLines(message) {
+    const lines = [];
+    let currentLine = '';
+    let i = 0;
+    while (i < message.length) {
+        const char = message[i];
+        if (char === '\r') {
+            lines.push(currentLine);
+            currentLine = '';
+            if (message[i + 1] === '\n') {
+                i++;
+            }
+        }
+        else if (char === '\n') {
+            lines.push(currentLine);
+            currentLine = '';
+        }
+        else {
+            currentLine += char;
+        }
+        i++;
+    }
+    if (currentLine || message.endsWith('\n') || message.endsWith('\r')) {
+        lines.push(currentLine);
+    }
+    return lines;
+}
+
+const headerMaxLengthRule = {
+    name: 'header-max-length',
+    check(commit, context) {
+        const maxLength = context.options?.maxLength;
+        if (maxLength === null || maxLength === undefined)
+            return [];
+        const header = reconstructHeader(commit);
+        if (header.length <= maxLength)
+            return [];
+        return [`header must be ≤ ${maxLength} characters but was ${header.length}: "${header}"`];
+    },
+};
+function reconstructHeader(commit) {
+    let header = commit.type;
+    if (commit.scope.length > 0) {
+        header += `(${commit.scope.join(',')})`;
+    }
+    if (commit.breaking) {
+        header += '!';
+    }
+    header += `: ${commit.subject}`;
+    return header;
+}
+
+const DEFAULT_IMPERATIVE_WORDLIST = {
+    added: 'add',
+    updated: 'update',
+    fixed: 'fix',
+    removed: 'remove',
+    changed: 'change',
+    modified: 'modify',
+    created: 'create',
+    deleted: 'delete',
+    improved: 'improve',
+    refactored: 'refactor',
+    implemented: 'implement',
+    renamed: 'rename',
+    moved: 'move',
+};
+const imperativeMoodRule = {
+    name: 'imperative-mood',
+    check(commit, context) {
+        const subject = commit.subject.trim();
+        if (subject === '')
+            return [];
+        const wordlist = context.options?.wordlist ?? DEFAULT_IMPERATIVE_WORDLIST;
+        const firstWord = extractFirstWord(subject).toLowerCase();
+        if (firstWord === '')
+            return [];
+        const imperative = wordlist[firstWord];
+        if (imperative === undefined)
+            return [];
+        return [`subject should use imperative mood: use "${imperative}" instead of "${firstWord}"`];
+    },
+};
+function extractFirstWord(subject) {
+    let end = 0;
+    while (end < subject.length && subject[end] !== ' ' && subject[end] !== '\t') {
+        end++;
+    }
+    return subject.slice(0, end);
+}
+
+const scopeEnumRule = {
+    name: 'scope-enum',
+    check(commit, context) {
+        const allowed = context.options?.scopes ?? [];
+        if (allowed.length === 0)
+            return [];
+        if (commit.scope.length === 0)
+            return [];
+        const violations = [];
+        for (const scope of commit.scope) {
+            if (!allowed.includes(scope)) {
+                violations.push(`scope must be one of [${allowed.join(', ')}] but found "${scope}"`);
+            }
+        }
+        return violations;
+    },
+};
+
+const subjectCaseRule = {
+    name: 'subject-case',
+    check(commit, context) {
+        const cases = context.options?.cases ?? [];
+        if (cases.length === 0)
+            return [];
+        const subject = commit.subject;
+        if (subject.trim() === '')
+            return [];
+        for (const form of cases) {
+            if (matchesCase(subject, form))
+                return [];
+        }
+        return [`subject must be one of [${cases.join(', ')}] but was "${subject}"`];
+    },
+};
+function matchesCase(subject, form) {
+    switch (form) {
+        case 'sentence-case':
+            return isSentenceCase(subject);
+        case 'lower-case':
+            return isLowerCase(subject);
+        case 'upper-case':
+            return isUpperCase(subject);
+        case 'kebab-case':
+            return isKebabCase(subject);
+        case 'snake-case':
+            return isSnakeCase(subject);
+        case 'start-case':
+            return isStartCase(subject);
+    }
+}
+function isSentenceCase(subject) {
+    for (const char of subject) {
+        if (isAlpha(char))
+            return isUpperChar(char);
+    }
+    return true;
+}
+function isLowerCase(subject) {
+    for (const char of subject) {
+        if (isAlpha(char) && isUpperChar(char))
+            return false;
+    }
+    return true;
+}
+function isUpperCase(subject) {
+    for (const char of subject) {
+        if (isAlpha(char) && isLowerChar(char))
+            return false;
+    }
+    return true;
+}
+function isKebabCase(subject) {
+    for (const char of subject) {
+        if (char === '-')
+            continue;
+        if (isAlpha(char) && isLowerChar(char))
+            continue;
+        if (isDigit(char))
+            continue;
+        return false;
+    }
+    return true;
+}
+function isSnakeCase(subject) {
+    for (const char of subject) {
+        if (char === '_')
+            continue;
+        if (isAlpha(char) && isLowerChar(char))
+            continue;
+        if (isDigit(char))
+            continue;
+        return false;
+    }
+    return true;
+}
+function isStartCase(subject) {
+    let expectUpper = true;
+    for (const char of subject) {
+        if (char === ' ') {
+            expectUpper = true;
+            continue;
+        }
+        if (expectUpper) {
+            if (isAlpha(char) && !isUpperChar(char))
+                return false;
+            expectUpper = false;
+        }
+    }
+    return true;
+}
+function isAlpha(char) {
+    const code = char.charCodeAt(0);
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function isDigit(char) {
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57;
+}
+function isUpperChar(char) {
+    const code = char.charCodeAt(0);
+    return code >= 65 && code <= 90;
+}
+function isLowerChar(char) {
+    const code = char.charCodeAt(0);
+    return code >= 97 && code <= 122;
+}
+
+const subjectEmptyRule = {
+    name: 'subject-empty',
+    check(commit) {
+        if (commit.subject.trim() === '') {
+            return ['subject must not be empty'];
+        }
+        return [];
+    },
+};
+
+const typeEnumRule = {
+    name: 'type-enum',
+    check(commit, context) {
+        const allowed = context.options?.types ?? [];
+        if (allowed.length === 0)
+            return [];
+        if (commit.type === '') {
+            return [`type must be one of [${allowed.join(', ')}] but was empty`];
+        }
+        if (!allowed.includes(commit.type)) {
+            return [`type must be one of [${allowed.join(', ')}] but was "${commit.type}"`];
+        }
+        return [];
+    },
+};
+
+const BUILT_IN_RULES = {
+    [typeEnumRule.name]: typeEnumRule,
+    [scopeEnumRule.name]: scopeEnumRule,
+    [subjectCaseRule.name]: subjectCaseRule,
+    [subjectEmptyRule.name]: subjectEmptyRule,
+    [headerMaxLengthRule.name]: headerMaxLengthRule,
+    [imperativeMoodRule.name]: imperativeMoodRule,
+};
+function validateCommit(commit, ruleset) {
+    return validateCommitWithRules(commit, ruleset, BUILT_IN_RULES);
+}
+function validateCommitWithRules(commit, ruleset, rules) {
+    const warnings = [];
+    const errors = [];
+    for (const [ruleName, config] of index_cjs_js$2.entries(ruleset)) {
+        const level = config[0];
+        if (level === 'off')
+            continue;
+        const rule = rules[ruleName];
+        if (rule === undefined)
+            continue;
+        const options = config.length > 1 ? config[1] : undefined;
+        const violations = rule.check(commit, { level, options: options });
+        for (const message of violations) {
+            const entry = { level, message, ruleName };
+            if (level === 'error') {
+                errors.push(entry);
+            }
+            else {
+                warnings.push(entry);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        warnings,
+        errors,
+    };
+}
+
+const PREVIEW_RESTART_STEP_ID = 'type';
+const previewStep = {
+    id: 'preview',
+    async run(ctx) {
+        const message = formatCommitMessage(ctx.draft);
+        writePreview(ctx, message);
+        const outcome = await confirm({
+            message: 'Commit this message?',
+            initial: true,
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (outcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        if (!outcome.value) {
+            return goto(PREVIEW_RESTART_STEP_ID);
+        }
+        return done();
+    },
+};
+function writePreview(ctx, message) {
+    const out = ctx.config.output ?? process.stdout;
+    const lines = ['', message];
+    const validation = validateCommit(parseConventionalCommit(message), ctx.config.validateRuleset);
+    for (const warning of validation.warnings) {
+        lines.push(`warn(${warning.ruleName}): ${warning.message}`);
+    }
+    for (const error of validation.errors) {
+        lines.push(`error(${error.ruleName}): ${error.message}`);
+    }
+    lines.push('');
+    out.write(lines.join('\n') + '\n');
+}
+
+function defaultScope(candidates) {
+    if (candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return candidates[0]?.name;
+    for (const candidate of candidates) {
+        if (isAncestorOfAll(candidate, candidates)) {
+            return candidate.name;
+        }
+    }
+    return undefined;
+}
+function isAncestorOfAll(candidate, all) {
+    const prefix = candidate.path.endsWith('/') ? candidate.path : `${candidate.path}/`;
+    for (const other of all) {
+        if (other === candidate)
+            continue;
+        if (!other.path.startsWith(prefix))
+            return false;
+    }
+    return true;
+}
+
+const EXCLUDED_PATH_SEGMENTS = ['/node_modules/', '/.git/'];
+function discoverScopes(stagedPaths, options) {
+    const seenPaths = index_cjs_js$5.createSet();
+    const discovered = [];
+    for (const stagedPath of stagedPaths) {
+        if (isExcluded(stagedPath))
+            continue;
+        const absolutePath = node_path.isAbsolute(stagedPath) ? stagedPath : node_path.join(options.cwd, stagedPath);
+        const projectRoot = index_cjs_js$6.findProjectRoot(absolutePath);
+        if (projectRoot === null)
+            continue;
+        if (seenPaths.has(projectRoot))
+            continue;
+        seenPaths.add(projectRoot);
+        const name = readProjectName(projectRoot);
+        if (name === null)
+            continue;
+        if (options.scopeFilter && !options.scopeFilter({ path: projectRoot, name }))
+            continue;
+        discovered.push({ name, path: projectRoot });
+    }
+    return discovered;
+}
+function readProjectName(projectRoot) {
+    const fromProjectJson = readManifestName(node_path.join(projectRoot, 'project.json'));
+    if (fromProjectJson !== null)
+        return fromProjectJson;
+    return readManifestName(node_path.join(projectRoot, 'package.json'));
+}
+function readManifestName(manifestPath) {
+    const content = index_cjs_js$7.readFileIfExists(manifestPath);
+    if (content === null)
+        return null;
+    try {
+        const manifest = index_cjs_js$8.parse(content);
+        return manifest.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isExcluded(stagedPath) {
+    const normalized = `/${stagedPath}/`;
+    for (const segment of EXCLUDED_PATH_SEGMENTS) {
+        if (normalized.includes(segment))
+            return true;
+    }
+    return false;
+}
+
+const EMPTY_STAGING_MESSAGE = 'No staged changes; stage something first.';
+const resolveScopeStep = {
+    id: 'resolve-scope',
+    async run(ctx) {
+        return runResolveScope(ctx);
+    },
+};
+function runResolveScope(ctx) {
+    const stagedPaths = ctx.config.stagedPathsProvider({ cwd: ctx.config.cwd });
+    if (stagedPaths.length === 0) {
+        return cancelled(index_cjs_js.createError(EMPTY_STAGING_MESSAGE));
+    }
+    const scopeFilter = ctx.config.scopeFilter;
+    const discovered = discoverScopes(stagedPaths, {
+        cwd: ctx.config.cwd,
+        ...(scopeFilter && { scopeFilter }),
+    });
+    ctx.candidateScopes = discovered.map((entry) => entry.name);
+    ctx.defaultScope = defaultScope(discovered);
+    return done();
+}
+
+const NO_SCOPE_CANDIDATES_MESSAGE = 'No scope candidates were discovered. Either stage a file under a project or set scopeOptional: true.';
+const scopeStep = {
+    id: 'scope',
+    async run(ctx) {
+        if (ctx.candidateScopes.length === 0) {
+            if (ctx.config.scopeOptional) {
+                ctx.draft = { ...ctx.draft, scope: [] };
+                return done();
+            }
+            return cancelled(index_cjs_js.createError(NO_SCOPE_CANDIDATES_MESSAGE));
+        }
+        if (ctx.config.scopeMulti) {
+            return runMultiselect(ctx);
+        }
+        return runSingleSelect(ctx);
+    },
+};
+async function runSingleSelect(ctx) {
+    const choices = ctx.candidateScopes.map((name) => ({ label: name, value: name }));
+    const initialIndex = resolveInitialIndex(ctx.candidateScopes, ctx.draft.scope, ctx.defaultScope);
+    const outcome = await select({
+        message: 'Select the scope of change:',
+        choices,
+        searchable: true,
+        ...(initialIndex >= 0 && { initial: initialIndex }),
+        ...(ctx.config.input && { input: ctx.config.input }),
+        ...(ctx.config.output && { output: ctx.config.output }),
+    });
+    if (outcome.result === PromptResult.Cancelled) {
+        return cancelled();
+    }
+    ctx.draft = { ...ctx.draft, scope: [outcome.value] };
+    return done();
+}
+async function runMultiselect(ctx) {
+    const choices = ctx.candidateScopes.map((name) => ({ label: name, value: name }));
+    const draftScopes = ctx.draft.scope ?? [];
+    const initialIndices = ctx.candidateScopes.map((name, index) => (draftScopes.includes(name) ? index : -1)).filter((index) => index >= 0);
+    const outcome = await multiselect({
+        message: 'Select the scopes of change:',
+        choices,
+        searchable: true,
+        ...(initialIndices.length > 0 && { initial: initialIndices }),
+        ...(ctx.config.scopeOptional ? { min: 0 } : { min: 1 }),
+        ...(ctx.config.input && { input: ctx.config.input }),
+        ...(ctx.config.output && { output: ctx.config.output }),
+    });
+    if (outcome.result === PromptResult.Cancelled) {
+        return cancelled();
+    }
+    ctx.draft = { ...ctx.draft, scope: outcome.value };
+    return done();
+}
+function resolveInitialIndex(candidates, draftScope, defaultScope) {
+    const firstDraftScope = draftScope?.[0];
+    if (firstDraftScope !== undefined) {
+        const index = candidates.indexOf(firstDraftScope);
+        if (index >= 0)
+            return index;
+    }
+    if (defaultScope !== undefined) {
+        const index = candidates.indexOf(defaultScope);
+        if (index >= 0)
+            return index;
+    }
+    return -1;
+}
+
+function countHeaderLength(draft, subject) {
+    return formatHeader({ ...draft, subject }).length;
+}
+
+const subjectStep = {
+    id: 'subject',
+    async run(ctx) {
+        const outcome = await text({
+            message: renderSubjectMessage(ctx, ''),
+            renderMessage: (value) => renderSubjectMessage(ctx, value),
+            ...(ctx.draft.subject && { initial: ctx.draft.subject }),
+            validate: (value) => {
+                const normalized = normalizeSubject(value);
+                if (normalized === '')
+                    return 'Subject must not be empty';
+                return undefined;
+            },
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (outcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        ctx.draft = { ...ctx.draft, subject: normalizeSubject(outcome.value) };
+        return done();
+    },
+};
+function normalizeSubject(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.endsWith('.'))
+        return trimmed.slice(0, -1).trimEnd();
+    return trimmed;
+}
+function renderSubjectMessage(ctx, subject) {
+    const budget = ctx.config.headerMaxLength;
+    if (budget === null)
+        return 'Subject:';
+    const used = countHeaderLength({ type: ctx.draft.type, scope: ctx.draft.scope }, subject);
+    const remaining = budget - used;
+    const countText = remaining < 0 ? `${-remaining} over ${budget}-char header` : `${remaining} chars left in ${budget}-char header`;
+    return `Subject (${colorize(remaining, countText)}):`;
+}
+function colorize(remaining, text) {
+    if (remaining < 0)
+        return style.red(text);
+    if (remaining <= 10)
+        return style.yellow(text);
+    return style.green(text);
+}
+
+const typeStep = {
+    id: 'type',
+    async run(ctx) {
+        const choices = ctx.config.types.map(typeToChoice);
+        const initialIndex = ctx.draft.type ? choices.findIndex((choice) => choice.value === ctx.draft.type) : -1;
+        const outcome = await select({
+            message: 'Select the type of change:',
+            choices,
+            searchable: true,
+            ...(initialIndex >= 0 && { initial: initialIndex }),
+            ...(ctx.config.input && { input: ctx.config.input }),
+            ...(ctx.config.output && { output: ctx.config.output }),
+        });
+        if (outcome.result === PromptResult.Cancelled) {
+            return cancelled();
+        }
+        ctx.draft = { ...ctx.draft, type: outcome.value };
+        return done();
+    },
+};
+
+const conventionalPreset$1 = index_cjs_js$2.freeze([
+    resolveScopeStep,
+    typeStep,
+    scopeStep,
+    subjectStep,
+    bodyStep,
+    breakingStep,
+    issuesStep,
+    previewStep,
+    commitStep,
+]);
+
+const CONVENTIONAL_TYPES = index_cjs_js$2.freeze([
+    'feat',
+    'fix',
+    'docs',
+    'style',
+    'refactor',
+    'perf',
+    'test',
+    'build',
+    'ci',
+    'chore',
+    'revert',
+]);
+const conventionalPreset = index_cjs_js$2.freeze({
+    'type-enum': ['error', { types: CONVENTIONAL_TYPES }],
+    'subject-empty': ['error'],
+    'scope-enum': ['off'],
+    'subject-case': ['off'],
+    'header-max-length': ['warn', { maxLength: 72 }],
+    'imperative-mood': ['warn'],
+});
+
+const TYPE_DESCRIPTIONS = {
+    feat: 'A new feature',
+    fix: 'A bug fix',
+    docs: 'Documentation only changes',
+    style: 'Changes that do not affect meaning (white-space, formatting, etc.)',
+    refactor: 'A code change that neither fixes a bug nor adds a feature',
+    perf: 'A code change that improves performance',
+    test: 'Adding missing tests or correcting existing tests',
+    build: 'Changes that affect the build system or external dependencies',
+    ci: 'Changes to our CI configuration files and scripts',
+    chore: 'Other changes that do not modify src or test files',
+    revert: 'Reverts a previous commit',
+};
+const DEFAULT_SESSION_TYPES = index_cjs_js$2.freeze(CONVENTIONAL_TYPES.map((name) => ({ name, description: describeType(name) })));
+function describeType(name) {
+    return TYPE_DESCRIPTIONS[name] ?? '';
+}
+
+function scopeMatcher(scopes) {
+    const normalizedScopes = index_cjs_js$5.createSet(scopes.map((s) => s.toLowerCase()));
+    return (ctx) => {
+        if (ctx.scope.length === 0)
+            return false;
+        return ctx.scope.some((s) => normalizedScopes.has(s.toLowerCase()));
+    };
+}
+function scopePrefixMatcher(prefixes) {
+    const normalizedPrefixes = prefixes.map((p) => p.toLowerCase());
+    return (ctx) => {
+        if (ctx.scope.length === 0)
+            return false;
+        return ctx.scope.some((s) => {
+            const normalized = s.toLowerCase();
+            return normalizedPrefixes.some((prefix) => normalized.startsWith(prefix));
+        });
+    };
+}
+function anyOf(...matchers) {
+    return (ctx) => matchers.some((matcher) => matcher(ctx));
+}
+const CI_SCOPE_MATCHER = scopeMatcher(['ci', 'cd', 'build', 'pipeline', 'workflow', 'actions']);
+const TOOLING_SCOPE_MATCHER = scopeMatcher(['tooling', 'workspace', 'monorepo', 'nx', 'root']);
+const TOOL_PREFIX_MATCHER = scopePrefixMatcher(['tool-']);
+const DEFAULT_INFRA_SCOPE_MATCHER = anyOf(CI_SCOPE_MATCHER, TOOLING_SCOPE_MATCHER, TOOL_PREFIX_MATCHER);
+
+exports.BUILT_IN_RULES = BUILT_IN_RULES;
+exports.CI_SCOPE_MATCHER = CI_SCOPE_MATCHER;
+exports.CONVENTIONAL_TYPES = CONVENTIONAL_TYPES;
+exports.DEFAULT_IMPERATIVE_WORDLIST = DEFAULT_IMPERATIVE_WORDLIST;
+exports.DEFAULT_INFRA_SCOPE_MATCHER = DEFAULT_INFRA_SCOPE_MATCHER;
+exports.DEFAULT_SESSION_TYPES = DEFAULT_SESSION_TYPES;
+exports.EMPTY_STAGING_MESSAGE = EMPTY_STAGING_MESSAGE;
+exports.NO_SCOPE_CANDIDATES_MESSAGE = NO_SCOPE_CANDIDATES_MESSAGE;
+exports.PREVIEW_RESTART_STEP_ID = PREVIEW_RESTART_STEP_ID;
+exports.SessionStatusValues = SessionStatus;
+exports.StepStatusValues = StepStatus;
+exports.TOOLING_SCOPE_MATCHER = TOOLING_SCOPE_MATCHER;
+exports.TOOL_PREFIX_MATCHER = TOOL_PREFIX_MATCHER;
+exports.anyOf = anyOf;
+exports.bodyStep = bodyStep;
+exports.breakingStep = breakingStep;
+exports.cancelled = cancelled;
+exports.commitStep = commitStep;
+exports.conventionalPreset = conventionalPreset;
+exports.conventionalStepPreset = conventionalPreset$1;
+exports.countHeaderLength = countHeaderLength;
+exports.defaultScope = defaultScope;
+exports.discoverScopes = discoverScopes;
+exports.done = done;
+exports.formatCommitMessage = formatCommitMessage;
+exports.formatHeader = formatHeader;
+exports.goto = goto;
+exports.headerMaxLengthRule = headerMaxLengthRule;
+exports.imperativeMoodRule = imperativeMoodRule;
+exports.isBreakingFooterKey = isBreakingFooterKey;
+exports.issuesStep = issuesStep;
+exports.normalizeSubject = normalizeSubject;
+exports.parseBody = parseBody;
+exports.parseConventionalCommit = parseConventionalCommit;
+exports.parseFooters = parseFooters;
+exports.parseHeader = parseHeader;
+exports.parseReferences = parseReferences;
+exports.previewStep = previewStep;
+exports.resolveScopeStep = resolveScopeStep;
+exports.scopeEnumRule = scopeEnumRule;
+exports.scopeMatcher = scopeMatcher;
+exports.scopePrefixMatcher = scopePrefixMatcher;
+exports.scopeStep = scopeStep;
+exports.subjectCaseRule = subjectCaseRule;
+exports.subjectEmptyRule = subjectEmptyRule;
+exports.subjectStep = subjectStep;
+exports.typeEnumRule = typeEnumRule;
+exports.typeStep = typeStep;
+exports.typeToChoice = typeToChoice;
+exports.validateCommit = validateCommit;
+exports.validateCommitWithRules = validateCommitWithRules;