@rshono/create 1.0.0-rc.0

package/dist/cli.mjs

@@ -0,0 +1,3930 @@
+// Bundled by rspack — edit src/ and rebuild. Includes @clack/prompts (MIT).
+import {fileURLToPath as __rspack_fileURLToPath} from "node:url";
+import {dirname as __rspack_dirname} from "node:path";
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+import { parseArgs, styleText as external_node_util_styleText } from "node:util";
+import node_process, { stdin as external_node_process_stdin, stdout as external_node_process_stdout } from "node:process";
+import node_readline from "node:readline";
+import "node:tty";
+import { existsSync as external_node_fs_existsSync, mkdirSync, readFileSync, readdirSync as external_node_fs_readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname as external_node_path_dirname, join as external_node_path_join, posix, relative as external_node_path_relative, resolve, sep } from "node:path";
+import { spawnSync } from "node:child_process";
+var __webpack_modules__ = ({
+347(module) {
+
+
+const ESC = '\x1B';
+const CSI = `${ESC}[`;
+const beep = '\u0007';
+
+const cursor = {
+  to(x, y) {
+    if (!y) return `${CSI}${x + 1}G`;
+    return `${CSI}${y + 1};${x + 1}H`;
+  },
+  move(x, y) {
+    let ret = '';
+
+    if (x < 0) ret += `${CSI}${-x}D`;
+    else if (x > 0) ret += `${CSI}${x}C`;
+
+    if (y < 0) ret += `${CSI}${-y}A`;
+    else if (y > 0) ret += `${CSI}${y}B`;
+
+    return ret;
+  },
+  up: (count = 1) => `${CSI}${count}A`,
+  down: (count = 1) => `${CSI}${count}B`,
+  forward: (count = 1) => `${CSI}${count}C`,
+  backward: (count = 1) => `${CSI}${count}D`,
+  nextLine: (count = 1) => `${CSI}E`.repeat(count),
+  prevLine: (count = 1) => `${CSI}F`.repeat(count),
+  left: `${CSI}G`,
+  hide: `${CSI}?25l`,
+  show: `${CSI}?25h`,
+  save: `${ESC}7`,
+  restore: `${ESC}8`
+}
+
+const scroll = {
+  up: (count = 1) => `${CSI}S`.repeat(count),
+  down: (count = 1) => `${CSI}T`.repeat(count)
+}
+
+const erase = {
+  screen: `${CSI}2J`,
+  up: (count = 1) => `${CSI}1J`.repeat(count),
+  down: (count = 1) => `${CSI}J`.repeat(count),
+  line: `${CSI}2K`,
+  lineEnd: `${CSI}K`,
+  lineStart: `${CSI}1K`,
+  lines(count) {
+    let clear = '';
+    for (let i = 0; i < count; i++)
+      clear += this.line + (i < count - 1 ? cursor.up() : '');
+    if (count)
+      clear += cursor.left;
+    return clear;
+  }
+}
+
+module.exports = { cursor, scroll, erase, beep };
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+
+;// CONCATENATED MODULE: external "node:util"
+
+;// CONCATENATED MODULE: external "node:process"
+
+;// CONCATENATED MODULE: external "node:readline"
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+/* MAIN */
+const getCodePointsLength = (() => {
+    const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+    return (input) => {
+        let surrogatePairsNr = 0;
+        SURROGATE_PAIR_RE.lastIndex = 0;
+        while (SURROGATE_PAIR_RE.test(input)) {
+            surrogatePairsNr += 1;
+        }
+        return input.length - surrogatePairsNr;
+    };
+})();
+const isFullWidth = (x) => {
+    return x === 0x3000 || x >= 0xFF01 && x <= 0xFF60 || x >= 0xFFE0 && x <= 0xFFE6;
+};
+const isWideNotCJKTNotEmoji = (x) => {
+    return x === 0x231B || x === 0x2329 || x >= 0x2FF0 && x <= 0x2FFF || x >= 0x3001 && x <= 0x303E || x >= 0x3099 && x <= 0x30FF || x >= 0x3105 && x <= 0x312F || x >= 0x3131 && x <= 0x318E || x >= 0x3190 && x <= 0x31E3 || x >= 0x31EF && x <= 0x321E || x >= 0x3220 && x <= 0x3247 || x >= 0x3250 && x <= 0x4DBF || x >= 0xFE10 && x <= 0xFE19 || x >= 0xFE30 && x <= 0xFE52 || x >= 0xFE54 && x <= 0xFE66 || x >= 0xFE68 && x <= 0xFE6B || x >= 0x1F200 && x <= 0x1F202 || x >= 0x1F210 && x <= 0x1F23B || x >= 0x1F240 && x <= 0x1F248 || x >= 0x20000 && x <= 0x2FFFD || x >= 0x30000 && x <= 0x3FFFD;
+};
+/* EXPORT */
+
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+/* IMPORT */
+
+/* HELPERS */
+const ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+const CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+const NO_TRUNCATION = { limit: Infinity, ellipsis: '' };
+/* MAIN */
+const getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+    /* CONSTANTS */
+    const LIMIT = truncationOptions.limit ?? Infinity;
+    const ELLIPSIS = truncationOptions.ellipsis ?? '';
+    const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+    const ANSI_WIDTH = 0;
+    const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+    const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+    const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+    const FULL_WIDTH_WIDTH = 2;
+    const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+    const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+    const PARSE_BLOCKS = [
+        [LATIN_RE, REGULAR_WIDTH],
+        [ANSI_RE, ANSI_WIDTH],
+        [CONTROL_RE, CONTROL_WIDTH],
+        [TAB_RE, TAB_WIDTH],
+        [EMOJI_RE, EMOJI_WIDTH],
+        [CJKT_WIDE_RE, WIDE_WIDTH],
+    ];
+    /* STATE */
+    let indexPrev = 0;
+    let index = 0;
+    let length = input.length;
+    let lengthExtra = 0;
+    let truncationEnabled = false;
+    let truncationIndex = length;
+    let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+    let unmatchedStart = 0;
+    let unmatchedEnd = 0;
+    let width = 0;
+    let widthExtra = 0;
+    /* PARSE LOOP */
+    outer: while (true) {
+        /* UNMATCHED */
+        if ((unmatchedEnd > unmatchedStart) || (index >= length && index > indexPrev)) {
+            const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+            lengthExtra = 0;
+            for (const char of unmatched.replaceAll(MODIFIER_RE, '')) {
+                const codePoint = char.codePointAt(0) || 0;
+                if (isFullWidth(codePoint)) {
+                    widthExtra = FULL_WIDTH_WIDTH;
+                }
+                else if (isWideNotCJKTNotEmoji(codePoint)) {
+                    widthExtra = WIDE_WIDTH;
+                }
+                else {
+                    widthExtra = REGULAR_WIDTH;
+                }
+                if ((width + widthExtra) > truncationLimit) {
+                    truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+                }
+                if ((width + widthExtra) > LIMIT) {
+                    truncationEnabled = true;
+                    break outer;
+                }
+                lengthExtra += char.length;
+                width += widthExtra;
+            }
+            unmatchedStart = unmatchedEnd = 0;
+        }
+        /* EXITING */
+        if (index >= length) {
+            break outer;
+        }
+        /* PARSE BLOCKS */
+        for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+            const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+            BLOCK_RE.lastIndex = index;
+            if (BLOCK_RE.test(input)) {
+                lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+                widthExtra = lengthExtra * BLOCK_WIDTH;
+                if ((width + widthExtra) > truncationLimit) {
+                    truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+                }
+                if ((width + widthExtra) > LIMIT) {
+                    truncationEnabled = true;
+                    break outer;
+                }
+                width += widthExtra;
+                unmatchedStart = indexPrev;
+                unmatchedEnd = index;
+                index = indexPrev = BLOCK_RE.lastIndex;
+                continue outer;
+            }
+        }
+        /* UNMATCHED INDEX */
+        index += 1;
+    }
+    /* RETURN */
+    return {
+        width: truncationEnabled ? truncationLimit : width,
+        index: truncationEnabled ? truncationIndex : length,
+        truncated: truncationEnabled,
+        ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+    };
+};
+/* EXPORT */
+/* export default */ const dist = (getStringTruncatedWidth);
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+/* IMPORT */
+
+/* HELPERS */
+const dist_NO_TRUNCATION = {
+    limit: Infinity,
+    ellipsis: '',
+    ellipsisWidth: 0,
+};
+/* MAIN */
+const fastStringWidth = (input, options = {}) => {
+    return dist(input, dist_NO_TRUNCATION, options).width;
+};
+/* EXPORT */
+/* export default */ const fast_string_width_dist = (fastStringWidth);
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+
+const ESC = '\x1B';
+const CSI = '\x9B';
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, 'y');
+const getClosingCode = (openingCode) => {
+    if (openingCode >= 30 && openingCode <= 37)
+        return 39;
+    if (openingCode >= 90 && openingCode <= 97)
+        return 39;
+    if (openingCode >= 40 && openingCode <= 47)
+        return 49;
+    if (openingCode >= 100 && openingCode <= 107)
+        return 49;
+    if (openingCode === 1 || openingCode === 2)
+        return 22;
+    if (openingCode === 3)
+        return 23;
+    if (openingCode === 4)
+        return 24;
+    if (openingCode === 7)
+        return 27;
+    if (openingCode === 8)
+        return 28;
+    if (openingCode === 9)
+        return 29;
+    if (openingCode === 0)
+        return 0;
+    return undefined;
+};
+const wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+const wrapWord = (rows, word, columns) => {
+    const characters = word[Symbol.iterator]();
+    let isInsideEscape = false;
+    let isInsideLinkEscape = false;
+    let lastRow = rows.at(-1);
+    let visible = lastRow === undefined ? 0 : fast_string_width_dist(lastRow);
+    let currentCharacter = characters.next();
+    let nextCharacter = characters.next();
+    let rawCharacterIndex = 0;
+    while (!currentCharacter.done) {
+        const character = currentCharacter.value;
+        const characterLength = fast_string_width_dist(character);
+        if (visible + characterLength <= columns) {
+            rows[rows.length - 1] += character;
+        }
+        else {
+            rows.push(character);
+            visible = 0;
+        }
+        if (character === ESC || character === CSI) {
+            isInsideEscape = true;
+            isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+        }
+        if (isInsideEscape) {
+            if (isInsideLinkEscape) {
+                if (character === ANSI_ESCAPE_BELL) {
+                    isInsideEscape = false;
+                    isInsideLinkEscape = false;
+                }
+            }
+            else if (character === ANSI_SGR_TERMINATOR) {
+                isInsideEscape = false;
+            }
+        }
+        else {
+            visible += characterLength;
+            if (visible === columns && !nextCharacter.done) {
+                rows.push('');
+                visible = 0;
+            }
+        }
+        currentCharacter = nextCharacter;
+        nextCharacter = characters.next();
+        rawCharacterIndex += character.length;
+    }
+    lastRow = rows.at(-1);
+    if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+        rows[rows.length - 2] += rows.pop();
+    }
+};
+const stringVisibleTrimSpacesRight = (string) => {
+    const words = string.split(' ');
+    let last = words.length;
+    while (last) {
+        if (fast_string_width_dist(words[last - 1])) {
+            break;
+        }
+        last--;
+    }
+    if (last === words.length) {
+        return string;
+    }
+    return words.slice(0, last).join(' ') + words.slice(last).join('');
+};
+const exec = (string, columns, options = {}) => {
+    if (options.trim !== false && string.trim() === '') {
+        return '';
+    }
+    let returnValue = '';
+    let escapeCode;
+    let escapeUrl;
+    const words = string.split(' ');
+    let rows = [''];
+    let rowLength = 0;
+    for (let index = 0; index < words.length; index++) {
+        const word = words[index];
+        if (options.trim !== false) {
+            const row = rows.at(-1) ?? '';
+            const trimmed = row.trimStart();
+            if (row.length !== trimmed.length) {
+                rows[rows.length - 1] = trimmed;
+                rowLength = fast_string_width_dist(trimmed);
+            }
+        }
+        if (index !== 0) {
+            if (rowLength >= columns &&
+                (options.wordWrap === false || options.trim === false)) {
+                rows.push('');
+                rowLength = 0;
+            }
+            if (rowLength || options.trim === false) {
+                rows[rows.length - 1] += ' ';
+                rowLength++;
+            }
+        }
+        const wordLength = fast_string_width_dist(word);
+        if (options.hard && wordLength > columns) {
+            const remainingColumns = columns - rowLength;
+            const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+            const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+            if (breaksStartingNextLine < breaksStartingThisLine) {
+                rows.push('');
+            }
+            wrapWord(rows, word, columns);
+            rowLength = fast_string_width_dist(rows.at(-1) ?? '');
+            continue;
+        }
+        if (rowLength + wordLength > columns && rowLength && wordLength) {
+            if (options.wordWrap === false && rowLength < columns) {
+                wrapWord(rows, word, columns);
+                rowLength = fast_string_width_dist(rows.at(-1) ?? '');
+                continue;
+            }
+            rows.push('');
+            rowLength = 0;
+        }
+        if (rowLength + wordLength > columns && options.wordWrap === false) {
+            wrapWord(rows, word, columns);
+            rowLength = fast_string_width_dist(rows.at(-1) ?? '');
+            continue;
+        }
+        rows[rows.length - 1] += word;
+        rowLength += wordLength;
+    }
+    if (options.trim !== false) {
+        rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+    }
+    const preString = rows.join('\n');
+    let inSurrogate = false;
+    for (let i = 0; i < preString.length; i++) {
+        const character = preString[i];
+        returnValue += character;
+        if (!inSurrogate) {
+            inSurrogate = character >= '\ud800' && character <= '\udbff';
+            if (inSurrogate) {
+                continue;
+            }
+        }
+        else {
+            inSurrogate = false;
+        }
+        if (character === ESC || character === CSI) {
+            GROUP_REGEX.lastIndex = i + 1;
+            const groupsResult = GROUP_REGEX.exec(preString);
+            const groups = groupsResult?.groups;
+            if (groups?.code !== undefined) {
+                const code = Number.parseFloat(groups.code);
+                escapeCode = code === END_CODE ? undefined : code;
+            }
+            else if (groups?.uri !== undefined) {
+                escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+            }
+        }
+        if (preString[i + 1] === '\n') {
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink('');
+            }
+            const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+            if (escapeCode && closingCode) {
+                returnValue += wrapAnsiCode(closingCode);
+            }
+        }
+        else if (character === '\n') {
+            if (escapeCode && getClosingCode(escapeCode)) {
+                returnValue += wrapAnsiCode(escapeCode);
+            }
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink(escapeUrl);
+            }
+        }
+    }
+    return returnValue;
+};
+const CRLF_OR_LF = /\r?\n/;
+function main_wrapAnsi(string, columns, options) {
+    return String(string)
+        .normalize()
+        .split(CRLF_OR_LF)
+        .map((line) => exec(line, columns, options))
+        .join('\n');
+}
+
+// EXTERNAL MODULE: ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var src = __webpack_require__(347);
+;// CONCATENATED MODULE: external "node:tty"
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+
+
+
+
+
+
+
+
+function findCursor(s, o, l) {
+  if (!l.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
+}
+function findTextCursor(s, o, l, i) {
+  const t = i.split(`
+`);
+  let n = 0, e = s;
+  for (const r of t) {
+    if (e <= r.length)
+      break;
+    e -= r.length + 1, n++;
+  }
+  for (n = Math.max(0, Math.min(t.length - 1, n + l)), e = Math.min(e, t[n].length) + o; e < 0 && n > 0; )
+    n--, e += t[n].length + 1;
+  for (; e > t[n].length && n < t.length - 1; )
+    e -= t[n].length + 1, n++;
+  e = Math.max(0, Math.min(t[n].length, e));
+  let h = 0;
+  for (let r = 0; r < n; r++)
+    h += t[r].length + 1;
+  return h + e;
+}
+
+const a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"], dist_t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+const dist_settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...dist_t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function updateSettings(n) {
+  if (n.aliases !== void 0) {
+    const e = n.aliases;
+    for (const s in e) {
+      if (!Object.hasOwn(e, s)) continue;
+      const i = e[s];
+      i === void 0 || !dist_settings.actions.has(i) || dist_settings.aliases.has(s) || dist_settings.aliases.set(s, i);
+    }
+  }
+  if (n.messages !== void 0) {
+    const e = n.messages;
+    e.cancel !== void 0 && (dist_settings.messages.cancel = e.cancel), e.error !== void 0 && (dist_settings.messages.error = e.error);
+  }
+  if (n.withGuide !== void 0 && (dist_settings.withGuide = n.withGuide !== false), n.date !== void 0) {
+    const e = n.date;
+    e.monthNames !== void 0 && (dist_settings.date.monthNames = [...e.monthNames]), e.messages !== void 0 && (e.messages.required !== void 0 && (dist_settings.date.messages.required = e.messages.required), e.messages.invalidMonth !== void 0 && (dist_settings.date.messages.invalidMonth = e.messages.invalidMonth), e.messages.invalidDay !== void 0 && (dist_settings.date.messages.invalidDay = e.messages.invalidDay), e.messages.afterMin !== void 0 && (dist_settings.date.messages.afterMin = e.messages.afterMin), e.messages.beforeMax !== void 0 && (dist_settings.date.messages.beforeMax = e.messages.beforeMax));
+  }
+}
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return dist_settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== void 0 && isActionKey(s, e))
+      return true;
+  return false;
+}
+
+function diffLines(i, s) {
+  if (i === s) return;
+  const e = i.split(`
+`), t = s.split(`
+`), r = Math.max(e.length, t.length), f = [];
+  for (let n = 0; n < r; n++)
+    e[n] !== t[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t.length,
+    numLines: r
+  };
+}
+
+const dist_R = globalThis.process.platform.startsWith("win");
+const CANCEL_SYMBOL = Symbol("clack:cancel");
+function dist_isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+function dist_block({
+  input: e = stdin,
+  output: r = stdout,
+  overwrite: o = true,
+  hideCursor: t = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n = (f, { name: a, sequence: p }) => {
+    const c = String(f);
+    if (isActionKey([c, a, p], "cancel")) {
+      t && r.write(cursor.show), process.exit(0);
+      return;
+    }
+    if (!o) return;
+    const i = a === "return" ? 0 : -1, m = a === "return" ? -1 : 0;
+    l.moveCursor(r, i, m, () => {
+      l.clearLine(r, 1, () => {
+        e.once("keypress", n);
+      });
+    });
+  };
+  return t && r.write(cursor.hide), e.once("keypress", n), () => {
+    e.off("keypress", n), t && r.write(cursor.show), e instanceof ReadStream && e.isTTY && !dist_R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+const dist_getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80, getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function dist_wrapTextWithPrefix(e, r, o, t = o, s = o, n) {
+  const f = dist_getColumns(e ?? external_node_process_stdout);
+  return main_wrapAnsi(r, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i, m) => {
+    const d = n ? n(c, i) : c;
+    return i === 0 ? `${t}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+
+function dist_runValidation(e, n) {
+  if ("~standard" in e) {
+    const a = e["~standard"].validate(n);
+    if (a instanceof Promise)
+      throw new TypeError(
+        "Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic."
+      );
+    return a.issues?.at(0)?.message;
+  }
+  return e(n);
+}
+
+class dist_V {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t, e = true) {
+    const { input: i = external_node_process_stdin, output: n = external_node_process_stdout, render: s, signal: r, ...o } = t;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t, e) {
+    const i = this._subscribers.get(t) ?? [];
+    i.push(e), this._subscribers.set(t, i);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t, e) {
+    this.setSubscriber(t, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t, e) {
+    this.setSubscriber(t, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t, ...e) {
+    const i = this._subscribers.get(t) ?? [], n = [];
+    for (const s of i)
+      s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+    for (const s of n)
+      s();
+  }
+  prompt() {
+    return new Promise((t) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener(
+          "abort",
+          () => {
+            this.state = "cancel", this.close();
+          },
+          { once: true }
+        );
+      }
+      this.rl = node_readline.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t, e) {
+    return t === "	";
+  }
+  _shouldSubmit(t, e) {
+    return true;
+  }
+  _setValue(t) {
+    this.value = t, this.emit("value", this.value);
+  }
+  _setUserInput(t, e) {
+    this.userInput = t ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && dist_settings.aliases.has(e.name) && this.emit("cursor", dist_settings.aliases.get(e.name)), dist_settings.actions.has(e.name) && this.emit("cursor", e.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, e), e?.name === "return" && this._shouldSubmit(t, e)) {
+      if (this.opts.validate) {
+        const i = dist_runValidation(this.opts.validate, this.value);
+        i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t = main_wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(src.cursor.move(-999, t * -1));
+  }
+  render() {
+    const t = main_wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(src.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+          let r = e.lines.find((o) => o >= n);
+          if (r === void 0) {
+            this._prevFrame = t;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(src.cursor.move(0, r - s)), this.output.write(src.erase.lines(1));
+            const o = t.split(`
+`);
+            this.output.write(o[r]), this._prevFrame = t, this.output.write(src.cursor.move(0, o.length - r - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n < s)
+              r = n;
+            else {
+              const h = r - s;
+              h > 0 && this.output.write(src.cursor.move(0, h));
+            }
+            this.output.write(src.erase.down());
+            const f = t.split(`
+`).slice(r);
+            this.output.write(f.join(`
+`)), this._prevFrame = t;
+            return;
+          }
+        }
+        this.output.write(src.erase.down());
+      }
+      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+    }
+  }
+}
+
+function p$1(l, e) {
+  if (l === void 0 || e.length === 0)
+    return 0;
+  const i = e.findIndex((s) => s.value === l);
+  return i !== -1 ? i : 0;
+}
+function dist_g(l, e) {
+  return (e.label ?? String(e.value)).toLowerCase().includes(l.toLowerCase());
+}
+function dist_m(l, e) {
+  if (e)
+    return l ? e : e[0];
+}
+let T$1 = class T extends (/* unused pure expression or super */ null && (dist_V)) {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #e = 0;
+  #s = "";
+  #t;
+  #i;
+  #n;
+  get cursor() {
+    return this.#e;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput)
+      return styleText(["inverse", "hidden"], "_");
+    if (this._cursor >= this.userInput.length)
+      return `${this.userInput}\u2588`;
+    const e = this.userInput.slice(0, this.cursor), t = this.userInput.slice(this.cursor, this.cursor + 1), i = this.userInput.slice(this.cursor + 1);
+    return `${e}${styleText("inverse", t)}${i}`;
+  }
+  get options() {
+    return typeof this.#i == "function" ? this.#i() : this.#i;
+  }
+  constructor(e) {
+    super(e), this.#i = e.options, this.#n = e.placeholder;
+    const t = this.options;
+    this.filteredOptions = [...t], this.multiple = e.multiple === true, this.#t = typeof e.options == "function" ? e.filter : e.filter ?? dist_g;
+    let i;
+    if (e.initialValue && Array.isArray(e.initialValue) ? this.multiple ? i = e.initialValue : i = e.initialValue.slice(0, 1) : !this.multiple && this.options.length > 0 && (i = [this.options[0]?.value]), i)
+      for (const s of i) {
+        const n = t.findIndex((o) => o.value === s);
+        n !== -1 && (this.toggleSelected(s), this.#e = n);
+      }
+    this.focusedValue = this.options[this.#e]?.value, this.on("key", (s, n) => this.#l(s, n)), this.on("userInput", (s) => this.#u(s));
+  }
+  _isActionKey(e, t) {
+    return e === "	" || this.multiple && this.isNavigating && t.name === "space" && e !== void 0 && e !== "";
+  }
+  #l(e, t) {
+    const i = t.name === "up", s = t.name === "down", n = t.name === "return", o = this.userInput === "" || this.userInput === "	", u = this.#n, a = this.options, f = u !== void 0 && u !== "" && a.some(
+      (r) => !r.disabled && (this.#t ? this.#t(u, r) : true)
+    );
+    if (t.name === "tab" && o && f) {
+      this.userInput === "	" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
+      return;
+    }
+    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = dist_m(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== void 0 && (t.name === "tab" || this.isNavigating && t.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
+  }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(e) {
+    this.filteredOptions.length !== 0 && (this.multiple ? this.selectedValues.includes(e) ? this.selectedValues = this.selectedValues.filter((t) => t !== e) : this.selectedValues = [...this.selectedValues, e] : this.selectedValues = [e]);
+  }
+  #u(e) {
+    if (e !== this.#s) {
+      this.#s = e;
+      const t = this.options;
+      e && this.#t ? this.filteredOptions = t.filter((n) => this.#t?.(e, n)) : this.filteredOptions = [...t];
+      const i = p$1(this.focusedValue, this.filteredOptions);
+      this.#e = findCursor(i, 0, this.filteredOptions);
+      const s = this.filteredOptions[this.#e];
+      s && !s.disabled ? this.focusedValue = s.value : this.focusedValue = void 0, this.multiple || (this.focusedValue !== void 0 ? this.toggleSelected(this.focusedValue) : this.deselectAll());
+    }
+  }
+};
+
+class dist_r extends dist_V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t) {
+    super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i) => {
+      this.output.write(src.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+
+const dist_ = {
+  Y: { type: "year", len: 4 },
+  M: { type: "month", len: 2 },
+  D: { type: "day", len: 2 }
+};
+function dist_M(r) {
+  return [...r].map((t) => dist_[t]);
+}
+function dist_P(r) {
+  const i = new Intl.DateTimeFormat(r, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(2e3, 0, 15)), s = [];
+  let n = "/";
+  for (const e of i)
+    e.type === "literal" ? n = e.value.trim() || e.value : (e.type === "year" || e.type === "month" || e.type === "day") && s.push({ type: e.type, len: e.type === "year" ? 4 : 2 });
+  return { segments: s, separator: n };
+}
+function dist_p(r) {
+  return Number.parseInt((r || "0").replace(/_/g, "0"), 10) || 0;
+}
+function dist_f(r) {
+  return {
+    year: dist_p(r.year),
+    month: dist_p(r.month),
+    day: dist_p(r.day)
+  };
+}
+function dist_c(r, t) {
+  return new Date(r || 2001, t || 1, 0).getDate();
+}
+function dist_b(r) {
+  const { year: t, month: i, day: s } = dist_f(r);
+  if (!t || t < 0 || t > 9999 || !i || i < 1 || i > 12 || !s || s < 1) return;
+  const n = new Date(Date.UTC(t, i - 1, s));
+  if (!(n.getUTCFullYear() !== t || n.getUTCMonth() !== i - 1 || n.getUTCDate() !== s))
+    return { year: t, month: i, day: s };
+}
+function dist_C(r) {
+  const t = dist_b(r);
+  return t ? new Date(Date.UTC(t.year, t.month - 1, t.day)) : void 0;
+}
+function dist_T(r, t, i, s) {
+  const n = i ? {
+    year: i.getUTCFullYear(),
+    month: i.getUTCMonth() + 1,
+    day: i.getUTCDate()
+  } : null, e = s ? {
+    year: s.getUTCFullYear(),
+    month: s.getUTCMonth() + 1,
+    day: s.getUTCDate()
+  } : null;
+  return r === "year" ? { min: n?.year ?? 1, max: e?.year ?? 9999 } : r === "month" ? {
+    min: n && t.year === n.year ? n.month : 1,
+    max: e && t.year === e.year ? e.month : 12
+  } : {
+    min: n && t.year === n.year && t.month === n.month ? n.day : 1,
+    max: e && t.year === e.year && t.month === e.month ? e.day : dist_c(t.year, t.month)
+  };
+}
+class U extends dist_V {
+  #i;
+  #o;
+  #t;
+  #h;
+  #u;
+  #e = { segmentIndex: 0, positionInSegment: 0 };
+  #n = true;
+  #s = null;
+  inlineError = "";
+  get segmentCursor() {
+    return { ...this.#e };
+  }
+  get segmentValues() {
+    return { ...this.#t };
+  }
+  get segments() {
+    return this.#i;
+  }
+  get separator() {
+    return this.#o;
+  }
+  get formattedValue() {
+    return this.#l(this.#t);
+  }
+  #l(t) {
+    return this.#i.map((i) => t[i.type]).join(this.#o);
+  }
+  #r() {
+    this._setUserInput(this.#l(this.#t)), this._setValue(dist_C(this.#t) ?? void 0);
+  }
+  constructor(t) {
+    const i = t.format ? { segments: dist_M(t.format), separator: t.separator ?? "/" } : dist_P(t.locale), s = t.separator ?? i.separator, n = t.format ? dist_M(t.format) : i.segments, e = t.initialValue ?? t.defaultValue, m = e ? {
+      year: String(e.getUTCFullYear()).padStart(4, "0"),
+      month: String(e.getUTCMonth() + 1).padStart(2, "0"),
+      day: String(e.getUTCDate()).padStart(2, "0")
+    } : { year: "____", month: "__", day: "__" }, o = n.map((a) => m[a.type]).join(s);
+    super({ ...t, initialUserInput: o }, false), this.#i = n, this.#o = s, this.#t = m, this.#h = t.minDate, this.#u = t.maxDate, this.#r(), this.on("cursor", (a) => this.#f(a)), this.on("key", (a, u) => this.#y(a, u)), this.on("finalize", () => this.#p(t));
+  }
+  #a() {
+    const t = Math.max(0, Math.min(this.#e.segmentIndex, this.#i.length - 1)), i = this.#i[t];
+    if (i)
+      return this.#e.positionInSegment = Math.max(
+        0,
+        Math.min(this.#e.positionInSegment, i.len - 1)
+      ), { segment: i, index: t };
+  }
+  #m(t) {
+    this.inlineError = "", this.#s = null;
+    const i = this.#a();
+    i && (this.#e.segmentIndex = Math.max(
+      0,
+      Math.min(this.#i.length - 1, i.index + t)
+    ), this.#e.positionInSegment = 0, this.#n = true);
+  }
+  #d(t) {
+    const i = this.#a();
+    if (!i) return;
+    const { segment: s } = i, n = this.#t[s.type], e = !n || n.replace(/_/g, "") === "", m = Number.parseInt((n || "0").replace(/_/g, "0"), 10) || 0, o = dist_T(
+      s.type,
+      dist_f(this.#t),
+      this.#h,
+      this.#u
+    );
+    let a;
+    e ? a = t === 1 ? o.min : o.max : a = Math.max(Math.min(o.max, m + t), o.min), this.#t = {
+      ...this.#t,
+      [s.type]: a.toString().padStart(s.len, "0")
+    }, this.#n = true, this.#s = null, this.#r();
+  }
+  #f(t) {
+    if (t)
+      switch (t) {
+        case "right":
+          return this.#m(1);
+        case "left":
+          return this.#m(-1);
+        case "up":
+          return this.#d(1);
+        case "down":
+          return this.#d(-1);
+      }
+  }
+  #y(t, i) {
+    if (i?.name === "backspace" || i?.sequence === "\x7F" || i?.sequence === "\b" || t === "\x7F" || t === "\b") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n) return;
+      if (!this.#t[n.segment.type].replace(/_/g, "")) {
+        this.#m(-1);
+        return;
+      }
+      this.#t[n.segment.type] = "_".repeat(n.segment.len), this.#n = true, this.#e.positionInSegment = 0, this.#r();
+      return;
+    }
+    if (i?.name === "tab") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n) return;
+      const e = i.shift ? -1 : 1, m = n.index + e;
+      m >= 0 && m < this.#i.length && (this.#e.segmentIndex = m, this.#e.positionInSegment = 0, this.#n = true);
+      return;
+    }
+    if (t && /^[0-9]$/.test(t)) {
+      const n = this.#a();
+      if (!n) return;
+      const { segment: e } = n, m = !this.#t[e.type].replace(/_/g, "");
+      if (this.#n && this.#s !== null && !m) {
+        const h = this.#s + t, d = { ...this.#t, [e.type]: h }, g = this.#g(d, e);
+        if (g) {
+          this.inlineError = g, this.#s = null, this.#n = false;
+          return;
+        }
+        this.inlineError = "", this.#t[e.type] = h, this.#s = null, this.#n = false, this.#r(), n.index < this.#i.length - 1 && (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true);
+        return;
+      }
+      this.#n && !m && (this.#t[e.type] = "_".repeat(e.len), this.#e.positionInSegment = 0), this.#n = false, this.#s = null;
+      const o = this.#t[e.type], a = o.indexOf("_"), u = a >= 0 ? a : Math.min(this.#e.positionInSegment, e.len - 1);
+      if (u < 0 || u >= e.len) return;
+      let l = o.slice(0, u) + t + o.slice(u + 1), D = false;
+      if (u === 0 && o === "__" && (e.type === "month" || e.type === "day")) {
+        const h = Number.parseInt(t, 10);
+        l = `0${t}`, D = h <= (e.type === "month" ? 1 : 2);
+      }
+      if (e.type === "year" && (l = (o.replace(/_/g, "") + t).padStart(e.len, "_")), !l.includes("_")) {
+        const h = { ...this.#t, [e.type]: l }, d = this.#g(h, e);
+        if (d) {
+          this.inlineError = d;
+          return;
+        }
+      }
+      this.inlineError = "", this.#t[e.type] = l;
+      const y = l.includes("_") ? void 0 : dist_b(this.#t);
+      if (y) {
+        const { year: h, month: d } = y, g = dist_c(h, d);
+        this.#t = {
+          year: String(Math.max(0, Math.min(9999, h))).padStart(4, "0"),
+          month: String(Math.max(1, Math.min(12, d))).padStart(2, "0"),
+          day: String(Math.max(1, Math.min(g, y.day))).padStart(2, "0")
+        };
+      }
+      this.#r();
+      const S = l.indexOf("_");
+      D ? (this.#n = true, this.#s = t) : S >= 0 ? this.#e.positionInSegment = S : a >= 0 && n.index < this.#i.length - 1 ? (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true) : this.#e.positionInSegment = Math.min(u + 1, e.len - 1);
+    }
+  }
+  #g(t, i) {
+    const { month: s, day: n } = dist_f(t);
+    if (i.type === "month" && (s < 0 || s > 12))
+      return dist_settings.date.messages.invalidMonth;
+    if (i.type === "day" && (n < 0 || n > 31))
+      return dist_settings.date.messages.invalidDay(31, "any month");
+  }
+  #p(t) {
+    const { year: i, month: s, day: n } = dist_f(this.#t);
+    if (i && s && n) {
+      const e = dist_c(i, s);
+      this.#t = {
+        ...this.#t,
+        day: String(Math.min(n, e)).padStart(2, "0")
+      };
+    }
+    this.value = dist_C(this.#t) ?? t.defaultValue ?? void 0;
+  }
+}
+
+let u$2 = class u extends (/* unused pure expression or super */ null && (dist_V)) {
+  options;
+  cursor = 0;
+  #t;
+  getGroupItems(t) {
+    return this.options.filter((r) => r.group === t);
+  }
+  isGroupSelected(t) {
+    const r = this.getGroupItems(t), e = this.value;
+    return e === void 0 ? false : r.every((s) => e.includes(s.value));
+  }
+  toggleValue() {
+    const t = this.options[this.cursor];
+    if (t !== void 0)
+      if (this.value === void 0 && (this.value = []), t.group === true) {
+        const r = t.value, e = this.getGroupItems(r);
+        this.isGroupSelected(r) ? this.value = this.value.filter(
+          (s) => e.findIndex((i) => i.value === s) === -1
+        ) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
+      } else {
+        const r = this.value.includes(t.value);
+        this.value = r ? this.value.filter((e) => e !== t.value) : [...this.value, t.value];
+      }
+  }
+  constructor(t) {
+    super(t, false);
+    const { options: r } = t;
+    this.#t = t.selectableGroups !== false, this.options = Object.entries(r).flatMap(([e, s]) => [
+      { value: e, group: true, label: e },
+      ...s.map((i) => ({ ...i, group: e }))
+    ]), this.value = [...t.initialValues ?? []], this.cursor = Math.max(
+      this.options.findIndex(({ value: e }) => e === t.cursorAt),
+      this.#t ? 0 : 1
+    ), this.on("cursor", (e) => {
+      switch (e) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+
+const dist_o = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+class dist_h extends dist_V {
+  #t = false;
+  #s;
+  focused = "editor";
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length)
+      return `${t}\u2588`;
+    const s = t.slice(0, this.cursor), r = t.slice(this.cursor, this.cursor + 1), i = t.slice(this.cursor + 1);
+    return r === `
+` ? `${s}\u2588
+${i}` : `${s}${external_node_util_styleText("inverse", r)}${i}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  #r(t) {
+    if (this.userInput.length === 0) {
+      this._setUserInput(t);
+      return;
+    }
+    this._setUserInput(
+      this.userInput.slice(0, this.cursor) + t + this.userInput.slice(this.cursor)
+    );
+  }
+  #i(t) {
+    const s = this.value ?? "";
+    switch (t) {
+      case "up":
+        this._cursor = findTextCursor(this._cursor, 0, -1, s);
+        return;
+      case "down":
+        this._cursor = findTextCursor(this._cursor, 0, 1, s);
+        return;
+      case "left":
+        this._cursor = findTextCursor(this._cursor, -1, 0, s);
+        return;
+      case "right":
+        this._cursor = findTextCursor(this._cursor, 1, 0, s);
+        return;
+    }
+  }
+  _shouldSubmit(t, s) {
+    if (this.#s)
+      return this.focused === "submit" ? true : (this.#r(`
+`), this._cursor++, false);
+    const r = this.#t;
+    return this.#t = true, r && this.cursor === this.userInput.length ? (this.userInput[this.cursor - 1] === `
+` && (this._setUserInput(
+      this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)
+    ), this._cursor--), true) : (this.#r(`
+`), this._cursor++, false);
+  }
+  constructor(t) {
+    const s = t.initialUserInput ?? t.initialValue;
+    super(
+      {
+        ...t,
+        initialUserInput: s
+      },
+      false
+    ), s !== void 0 && (this._cursor = s.length), this.#s = t.showSubmit ?? false, this.on("key", (r, i) => {
+      if (i?.name && dist_o.has(i.name)) {
+        this.#t = false, this.#i(i.name);
+        return;
+      }
+      if (r === "	" && this.#s) {
+        this.focused = this.focused === "editor" ? "submit" : "editor";
+        return;
+      }
+      if (i?.name !== "return") {
+        if (this.#t = false, i?.name === "backspace" && this.cursor > 0) {
+          this._setUserInput(
+            this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)
+          ), this._cursor--;
+          return;
+        }
+        if (i?.name === "delete" && this.cursor < this.userInput.length) {
+          this._setUserInput(
+            this.userInput.slice(0, this.cursor) + this.userInput.slice(this.cursor + 1)
+          );
+          return;
+        }
+        r && (this.#s && this.focused === "submit" && (this.focused = "editor"), this.#r(r ?? ""), this._cursor++);
+      }
+    }), this.on("userInput", (r) => {
+      this._setValue(r);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+}
+
+class dist_a extends dist_V {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor]?.value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e) => e.disabled !== true);
+  }
+  toggleAll() {
+    const e = this._enabledOptions, i = this.value !== void 0 && this.value.length === e.length;
+    this.value = i ? [] : e.map((t) => t.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i = this._enabledOptions.filter((t) => !e.includes(t.value));
+    this.value = i.map((t) => t.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i) => i !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i = Math.max(
+      this.options.findIndex(({ value: t }) => t === e.cursorAt),
+      0
+    );
+    this.cursor = this.options[i]?.disabled ? findCursor(i, 1, this.options) : i, this.on("key", (t, l) => {
+      l.name === "a" && this.toggleAll(), l.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t) => {
+      switch (t) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+}
+
+let u$1 = class u extends (/* unused pure expression or super */ null && (dist_V)) {
+  _mask = "\u2022";
+  get cursor() {
+    return this._cursor;
+  }
+  get masked() {
+    return this.userInput.replaceAll(/./g, this._mask);
+  }
+  get userInputWithCursor() {
+    if (this.state === "submit" || this.state === "cancel")
+      return this.masked;
+    const t = this.userInput;
+    if (this.cursor >= t.length)
+      return `${this.masked}${styleText(["inverse", "hidden"], "_")}`;
+    const s = this.masked, r = s.slice(0, this.cursor), i = s.slice(this.cursor, this.cursor + 1), o = s.slice(this.cursor + 1);
+    return `${r}${styleText("inverse", i)}${o}`;
+  }
+  clear() {
+    this._clearUserInput();
+  }
+  constructor({ mask: t, ...s }) {
+    super(s), this._mask = t ?? "\u2022", this.on("userInput", (r) => {
+      this._setValue(r);
+    }), this.on("finalize", () => {
+      this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+let n$1 = class n extends dist_V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === void 0 ? void 0 : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t = o === -1 ? 0 : o;
+    this.cursor = this.options[t]?.disabled ? findCursor(t, 1, this.options) : t, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+
+class dist_u extends dist_V {
+  options;
+  cursor = 0;
+  constructor(t) {
+    super(t, false), this.options = t.options;
+    const s = t.caseSensitive === true, i = this.options.map(({ value: [e] }) => s ? e : e?.toLowerCase());
+    this.cursor = Math.max(i.indexOf(t.initialValue), 0), this.on("key", (e) => {
+      if (!e)
+        return;
+      const o = s ? e : e.toLowerCase();
+      if (!i.includes(o))
+        return;
+      const n = this.options.find(({ value: [r] }) => s ? r === o : r?.toLowerCase() === o);
+      n && (this.value = n.value, this.state = "submit", this.emit("submit"));
+    });
+  }
+}
+
+class dist_n extends dist_V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length)
+      return `${this.userInput}\u2588`;
+    const r = t.slice(0, this.cursor), s = t.slice(this.cursor, this.cursor + 1), e = t.slice(this.cursor + 1);
+    return `${r}${external_node_util_styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t) {
+    super({
+      ...t,
+      initialUserInput: t.initialUserInput ?? t.initialValue
+    }), this.on("userInput", (r) => {
+      this._setValue(r);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+}
+
+
+
+;// CONCATENATED MODULE: external "node:fs"
+
+;// CONCATENATED MODULE: external "node:path"
+
+;// CONCATENATED MODULE: ../../node_modules/.pnpm/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
+
+
+
+
+
+
+
+
+
+
+function isUnicodeSupported() {
+	if (node_process.platform !== 'win32') {
+		return node_process.env.TERM !== 'linux'; // Linux console (kernel)
+	}
+
+	return Boolean(node_process.env.CI)
+		|| Boolean(node_process.env.WT_SESSION) // Windows Terminal
+		|| Boolean(node_process.env.TERMINUS_SUBLIME) // Terminus (<0.2.27)
+		|| node_process.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
+		|| node_process.env.TERM_PROGRAM === 'Terminus-Sublime'
+		|| node_process.env.TERM_PROGRAM === 'vscode'
+		|| node_process.env.TERM === 'xterm-256color'
+		|| node_process.env.TERM === 'alacritty'
+		|| node_process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+}
+
+const unicode = isUnicodeSupported(), isCI = () => process.env.CI === "true", isTTY = (o) => o.isTTY === true, unicodeOr = (o, e) => unicode ? o : e, S_STEP_ACTIVE = unicodeOr("\u25C6", "*"), S_STEP_CANCEL = unicodeOr("\u25A0", "x"), S_STEP_ERROR = unicodeOr("\u25B2", "x"), S_STEP_SUBMIT = unicodeOr("\u25C7", "o"), S_BAR_START = unicodeOr("\u250C", "T"), S_BAR = unicodeOr("\u2502", "|"), S_BAR_END = unicodeOr("\u2514", "\u2014"), S_BAR_START_RIGHT = (/* unused pure expression or super */ null && (unicodeOr("\u2510", "T"))), S_BAR_END_RIGHT = (/* unused pure expression or super */ null && (unicodeOr("\u2518", "\u2014"))), S_RADIO_ACTIVE = unicodeOr("\u25CF", ">"), S_RADIO_INACTIVE = unicodeOr("\u25CB", " "), S_CHECKBOX_ACTIVE = (/* unused pure expression or super */ null && (unicodeOr("\u25FB", "[\u2022]"))), S_CHECKBOX_SELECTED = (/* unused pure expression or super */ null && (unicodeOr("\u25FC", "[+]"))), S_CHECKBOX_INACTIVE = (/* unused pure expression or super */ null && (unicodeOr("\u25FB", "[ ]"))), S_PASSWORD_MASK = (/* unused pure expression or super */ null && (unicodeOr("\u25AA", "\u2022"))), S_BAR_H = unicodeOr("\u2500", "-"), S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+"), S_CONNECT_LEFT = unicodeOr("\u251C", "+"), S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+"), S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+"), S_CORNER_TOP_LEFT = (/* unused pure expression or super */ null && (unicodeOr("\u256D", "+"))), S_INFO = unicodeOr("\u25CF", "\u2022"), S_SUCCESS = unicodeOr("\u25C6", "*"), S_WARN = unicodeOr("\u25B2", "!"), S_ERROR = unicodeOr("\u25A0", "x"), symbol = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return external_node_util_styleText("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return external_node_util_styleText("red", S_STEP_CANCEL);
+    case "error":
+      return external_node_util_styleText("yellow", S_STEP_ERROR);
+    case "submit":
+      return external_node_util_styleText("green", S_STEP_SUBMIT);
+  }
+}, symbolBar = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return external_node_util_styleText("cyan", S_BAR);
+    case "cancel":
+      return external_node_util_styleText("red", S_BAR);
+    case "error":
+      return external_node_util_styleText("yellow", S_BAR);
+    case "submit":
+      return external_node_util_styleText("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o, e) {
+  const r = [`${e ? `${external_node_util_styleText("cyan", S_BAR)}  ` : ""}${o.join(" \u2022 ")}`];
+  return e && r.push(external_node_util_styleText("cyan", S_BAR_END)), r;
+}
+
+const dist_I = (l, e, w, p, b, C = false) => {
+  let r = e, O = 0;
+  if (C)
+    for (let i = p - 1; i >= w; i--) {
+      const m = l[i];
+      if (m && (r -= m.length), O++, r <= b) break;
+    }
+  else
+    for (let i = w; i < p; i++) {
+      const m = l[i];
+      if (m && (r -= m.length), O++, r <= b) break;
+    }
+  return { lineCount: r, removals: O };
+};
+const limitOptions = ({
+  cursor: l,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C = 0,
+  rowPadding: r = 4
+}) => {
+  const i = dist_getColumns(p) - C, m = getRows(p), M = external_node_util_styleText("dim", "..."), v = Math.max(m - r, 0), a = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l >= a - 3 && (f = Math.max(
+    Math.min(l - a + 3, e.length - a),
+    0
+  ));
+  let d = a < e.length && f > 0, c = a < e.length && f + a < e.length;
+  const W = Math.min(
+    f + a,
+    e.length
+  ), s = [];
+  let g = 0;
+  d && g++, c && g++;
+  const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+  for (let t = T; t < y; t++) {
+    const n = e[t], o = n ? w(n, t === l) : "", h = main_wrapAnsi(o, i, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h), g += h.length;
+  }
+  if (g > v) {
+    let t = 0, n = 0, o = g;
+    const h = l - T;
+    let u = v;
+    const L = () => dist_I(s, o, 0, h, u), E = () => dist_I(
+      s,
+      o,
+      h + 1,
+      s.length,
+      u,
+      true
+    );
+    d ? ({ lineCount: o, removals: t } = L(), o > u && (c || (u -= 1), { lineCount: o, removals: n } = E())) : (c || (u -= 1), { lineCount: o, removals: n } = E(), o > u && (u -= 1, { lineCount: o, removals: t } = L())), t > 0 && (d = true, s.splice(0, t)), n > 0 && (c = true, s.splice(s.length - n, n));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t of s)
+    for (const n of t)
+      x.push(n);
+  return c && x.push(M), x;
+};
+
+function prompts_dist_P(t) {
+  return t.label ?? String(t.value ?? "");
+}
+function dist_E(t, c) {
+  if (!t)
+    return true;
+  const n = (c.label ?? String(c.value ?? "")).toLowerCase(), i = (c.hint ?? "").toLowerCase(), l = String(c.value).toLowerCase(), o = t.toLowerCase();
+  return n.includes(o) || i.includes(o) || l.includes(o);
+}
+function dist_N(t, c) {
+  const n = [];
+  for (const i of c)
+    t.includes(i.value) && n.push(i);
+  return n;
+}
+const autocomplete = (t) => new AutocompletePrompt({
+  options: t.options,
+  initialValue: t.initialValue ? [t.initialValue] : void 0,
+  initialUserInput: t.initialUserInput,
+  placeholder: t.placeholder,
+  filter: t.filter ?? ((n, i) => dist_E(n, i)),
+  signal: t.signal,
+  input: t.input,
+  output: t.output,
+  validate: t.validate,
+  render() {
+    const n = t.withGuide ?? settings.withGuide, i = n ? [`${styleText("gray", S_BAR)}`, `${symbol(this.state)}  ${t.message}`] : [`${symbol(this.state)}  ${t.message}`], l = this.userInput, o = this.options, m = t.placeholder, p = l === "" && m !== void 0, $ = (r, s) => {
+      const a = prompts_dist_P(r), u = r.hint && r.value === this.focusedValue ? styleText("dim", ` (${r.hint})`) : "";
+      switch (s) {
+        case "active":
+          return `${styleText("green", S_RADIO_ACTIVE)} ${a}${u}`;
+        case "inactive":
+          return `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", a)}`;
+        case "disabled":
+          return `${styleText("gray", S_RADIO_INACTIVE)} ${styleText(["strikethrough", "gray"], a)}`;
+      }
+    };
+    switch (this.state) {
+      case "submit": {
+        const r = dist_N(this.selectedValues, o), s = r.length > 0 ? `  ${styleText("dim", r.map(prompts_dist_P).join(", "))}` : "", a = n ? styleText("gray", S_BAR) : "";
+        return `${i.join(`
+`)}
+${a}${s}`;
+      }
+      case "cancel": {
+        const r = l ? `  ${styleText(["strikethrough", "dim"], l)}` : "", s = n ? styleText("gray", S_BAR) : "";
+        return `${i.join(`
+`)}
+${s}${r}`;
+      }
+      default: {
+        const r = this.state === "error" ? "yellow" : "cyan", s = n ? `${styleText(r, S_BAR)}  ` : "", a = n ? styleText(r, S_BAR_END) : "";
+        let u = "";
+        if (this.isNavigating || p) {
+          const d = p ? m : l;
+          u = d !== "" ? ` ${styleText("dim", d)}` : "";
+        } else
+          u = ` ${this.userInputWithCursor}`;
+        const V = this.filteredOptions.length !== o.length ? styleText(
+          "dim",
+          ` (${this.filteredOptions.length} match${this.filteredOptions.length === 1 ? "" : "es"})`
+        ) : "", y = this.filteredOptions.length === 0 && l ? [`${s}${styleText("yellow", "No matches found")}`] : [], b = this.state === "error" ? [`${s}${styleText("yellow", this.error)}`] : [];
+        n && i.push(`${s.trimEnd()}`), i.push(
+          `${s}${styleText("dim", "Search:")}${u}${V}`,
+          ...y,
+          ...b
+        );
+        const v = [
+          `${styleText("dim", "\u2191/\u2193")} to select`,
+          `${styleText("dim", "Enter:")} confirm`,
+          `${styleText("dim", "Type:")} to search`
+        ], g = [`${s}${v.join(" \u2022 ")}`, a], O = this.filteredOptions.length === 0 ? [] : limitOptions({
+          cursor: this.cursor,
+          options: this.filteredOptions,
+          columnPadding: n ? 3 : 0,
+          // for `|  ` when guide is shown
+          rowPadding: i.length + g.length,
+          style: (d, f) => $(
+            d,
+            d.disabled ? "disabled" : f ? "active" : "inactive"
+          ),
+          maxItems: t.maxItems,
+          output: t.output
+        });
+        return [
+          ...i,
+          ...O.map((d) => `${s}${d}`),
+          ...g
+        ].join(`
+`);
+      }
+    }
+  }
+}).prompt(), autocompleteMultiselect = (t) => {
+  const c = (i, l, o, m) => {
+    const p = o.includes(i.value), $ = i.label ?? String(i.value ?? ""), r = i.hint && m !== void 0 && i.value === m ? styleText("dim", ` (${i.hint})`) : "", s = p ? styleText("green", S_CHECKBOX_SELECTED) : styleText("dim", S_CHECKBOX_INACTIVE);
+    return i.disabled ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${styleText(["strikethrough", "gray"], $)}` : l ? `${s} ${$}${r}` : `${s} ${styleText("dim", $)}`;
+  }, n = new AutocompletePrompt({
+    options: t.options,
+    multiple: true,
+    placeholder: t.placeholder,
+    filter: t.filter ?? ((i, l) => dist_E(i, l)),
+    validate: () => {
+      if (t.required && n.selectedValues.length === 0)
+        return "Please select at least one item";
+    },
+    initialValue: t.initialValues,
+    signal: t.signal,
+    input: t.input,
+    output: t.output,
+    render() {
+      const i = t.withGuide ?? settings.withGuide, l = `${i ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${t.message}
+`, o = this.userInput, m = t.placeholder, p = o === "" && m !== void 0, $ = this.isNavigating || p ? styleText("dim", p ? m : o) : this.userInputWithCursor, r = this.options, s = this.filteredOptions.length !== r.length ? styleText(
+        "dim",
+        ` (${this.filteredOptions.length} match${this.filteredOptions.length === 1 ? "" : "es"})`
+      ) : "";
+      switch (this.state) {
+        case "submit":
+          return `${l}${i ? `${styleText("gray", S_BAR)}  ` : ""}${styleText(
+            "dim",
+            `${this.selectedValues.length} items selected`
+          )}`;
+        case "cancel":
+          return `${l}${i ? `${styleText("gray", S_BAR)}  ` : ""}${styleText(
+            ["strikethrough", "dim"],
+            o
+          )}`;
+        default: {
+          const a = this.state === "error" ? "yellow" : "cyan", u = i ? `${styleText(a, S_BAR)}  ` : "", V = i ? styleText(a, S_BAR_END) : "", y = [
+            `${styleText("dim", "\u2191/\u2193")} to navigate`,
+            `${styleText("dim", this.isNavigating ? "Space/Tab:" : "Tab:")} select`,
+            `${styleText("dim", "Enter:")} confirm`,
+            `${styleText("dim", "Type:")} to search`
+          ], b = this.filteredOptions.length === 0 && o ? [`${u}${styleText("yellow", "No matches found")}`] : [], v = this.state === "error" ? [`${u}${styleText("yellow", this.error)}`] : [], g = [
+            ...`${l}${i ? styleText(a, S_BAR) : ""}`.split(`
+`),
+            `${u}${styleText("dim", "Search:")} ${$}${s}`,
+            ...b,
+            ...v
+          ], O = [`${u}${y.join(" \u2022 ")}`, V], d = limitOptions({
+            cursor: this.cursor,
+            options: this.filteredOptions,
+            style: (f, _) => c(f, _, this.selectedValues, this.focusedValue),
+            maxItems: t.maxItems,
+            output: t.output,
+            rowPadding: g.length + O.length
+          });
+          return [
+            ...g,
+            ...d.map((f) => `${u}${f}`),
+            ...O
+          ].join(`
+`);
+        }
+      }
+    }
+  });
+  return n.prompt();
+};
+
+const J = (/* unused pure expression or super */ null && ([
+  S_CORNER_TOP_LEFT,
+  S_CORNER_TOP_RIGHT,
+  S_CORNER_BOTTOM_LEFT,
+  S_CORNER_BOTTOM_RIGHT
+])), K = (/* unused pure expression or super */ null && ([S_BAR_START, S_BAR_START_RIGHT, S_BAR_END, S_BAR_END_RIGHT]));
+function A$1(n, e, t, o) {
+  let i = t, f = t;
+  return o === "center" ? i = Math.floor((e - n) / 2) : o === "right" && (i = e - n - t), f = e - i - n, [i, f];
+}
+const Q = (n) => n;
+const box = (n = "", e = "", t) => {
+  const o = t?.output ?? process.stdout, i = getColumns(o), R = 1 * 2, u = t?.titlePadding ?? 1, h = t?.contentPadding ?? 2, w = t?.width === void 0 || t.width === "auto" ? 1 : Math.min(1, t.width), m = t?.withGuide ?? settings.withGuide ? `${S_BAR} ` : "", b = t?.formatBorder ?? Q, a = (t?.rounded ? J : K).map(b), _ = b(S_BAR_H), B = b(S_BAR), p = l(m), x = l(e), O = i - p;
+  let r = Math.floor(i * w) - p;
+  if (t?.width === "auto") {
+    const c = n.split(`
+`);
+    let s = x + u * 2;
+    for (const G of c) {
+      const P = l(G) + h * 2;
+      P > s && (s = P);
+    }
+    const g = s + R;
+    g < r && (r = g);
+  }
+  r % 2 !== 0 && (r < O ? r++ : r--);
+  const d = r - R, S = d - u * 2, T = x > S ? `${e.slice(0, S - 3)}...` : e, [y, W] = A$1(
+    l(T),
+    d,
+    u,
+    t?.titleAlign
+  ), L = wrapAnsi(n, d - h * 2, {
+    hard: true,
+    trim: false
+  });
+  o.write(
+    `${m}${a[0]}${_.repeat(y)}${T}${_.repeat(W)}${a[1]}
+`
+  );
+  const E = L.split(`
+`);
+  for (const c of E) {
+    const [s, g] = A$1(
+      l(c),
+      d,
+      h,
+      t?.contentAlign
+    );
+    o.write(
+      `${m}${B}${" ".repeat(s)}${c}${" ".repeat(g)}${B}
+`
+    );
+  }
+  o.write(`${m}${a[2]}${_.repeat(d)}${a[3]}
+`);
+};
+
+const dist_confirm = (i) => {
+  const a = i.active ?? "Yes", s = i.inactive ?? "No";
+  return new dist_r({
+    active: a,
+    inactive: s,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValue: i.initialValue ?? true,
+    render() {
+      const e = i.withGuide ?? dist_settings.withGuide, u = `${symbol(this.state)}  `, l = e ? `${external_node_util_styleText("gray", S_BAR)}  ` : "", f = dist_wrapTextWithPrefix(
+        i.output,
+        i.message,
+        l,
+        u
+      ), o = `${e ? `${external_node_util_styleText("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a : s;
+      switch (this.state) {
+        case "submit": {
+          const r = e ? `${external_node_util_styleText("gray", S_BAR)}  ` : "";
+          return `${o}${r}${external_node_util_styleText("dim", c)}`;
+        }
+        case "cancel": {
+          const r = e ? `${external_node_util_styleText("gray", S_BAR)}  ` : "";
+          return `${o}${r}${external_node_util_styleText(["strikethrough", "dim"], c)}${e ? `
+${external_node_util_styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r = e ? `${external_node_util_styleText("cyan", S_BAR)}  ` : "", g = e ? external_node_util_styleText("cyan", S_BAR_END) : "";
+          return `${o}${r}${this.value ? `${external_node_util_styleText("green", S_RADIO_ACTIVE)} ${a}` : `${external_node_util_styleText("dim", S_RADIO_INACTIVE)} ${external_node_util_styleText("dim", a)}`}${i.vertical ? e ? `
+${external_node_util_styleText("cyan", S_BAR)}  ` : `
+` : ` ${external_node_util_styleText("dim", "/")} `}${this.value ? `${external_node_util_styleText("dim", S_RADIO_INACTIVE)} ${external_node_util_styleText("dim", s)}` : `${external_node_util_styleText("green", S_RADIO_ACTIVE)} ${s}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+
+const date = (e) => {
+  const r = e.validate;
+  return new DatePrompt({
+    ...e,
+    validate(t) {
+      if (t === void 0)
+        return e.defaultValue !== void 0 ? void 0 : r ? runValidation(r, t) : settings.date.messages.required;
+      const o = (i) => i.toISOString().slice(0, 10);
+      if (e.minDate && o(t) < o(e.minDate))
+        return settings.date.messages.afterMin(e.minDate);
+      if (e.maxDate && o(t) > o(e.maxDate))
+        return settings.date.messages.beforeMax(e.maxDate);
+      if (r) return runValidation(r, t);
+    },
+    render() {
+      const t = (e?.withGuide ?? settings.withGuide) !== false, i = `${`${t ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, l = this.state !== "initial" ? this.state : "active", d = prompts_dist_b(this, l), c = this.value instanceof Date ? this.formattedValue : "";
+      switch (this.state) {
+        case "error": {
+          const a = this.error ? `  ${styleText("yellow", this.error)}` : "", s = t ? `${styleText("yellow", S_BAR)}  ` : "", f = t ? styleText("yellow", S_BAR_END) : "";
+          return `${i.trim()}
+${s}${d}
+${f}${a}
+`;
+        }
+        case "submit": {
+          const a = c ? `  ${styleText("dim", c)}` : "", s = t ? styleText("gray", S_BAR) : "";
+          return `${i}${s}${a}`;
+        }
+        case "cancel": {
+          const a = c ? `  ${styleText(["strikethrough", "dim"], c)}` : "", s = t ? styleText("gray", S_BAR) : "";
+          return `${i}${s}${a}${c.trim() ? `
+${s}` : ""}`;
+        }
+        default: {
+          const a = t ? `${styleText("cyan", S_BAR)}  ` : "", s = t ? styleText("cyan", S_BAR_END) : "", f = t ? `${styleText("cyan", S_BAR)}  ` : "", g = this.inlineError ? `
+${f}${styleText("yellow", this.inlineError)}` : "";
+          return `${i}${a}${d}${g}
+${s}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+function prompts_dist_b(e, r) {
+  const t = e.segmentValues, o = e.segmentCursor;
+  if (r === "submit" || r === "cancel")
+    return e.formattedValue;
+  const i = styleText("gray", e.separator);
+  return e.segments.map((l, d) => {
+    const c = d === o.segmentIndex && !["submit", "cancel"].includes(r), a = prompts_dist_p[l.type];
+    return dist_x(t[l.type], { isActive: c, label: a });
+  }).join(i);
+}
+function dist_x(e, r) {
+  const t = !e || e.replace(/_/g, "") === "";
+  return r.isActive ? styleText("inverse", t ? r.label : e.replace(/_/g, " ")) : t ? styleText("dim", r.label) : e.replace(/_/g, styleText("dim", " "));
+}
+const prompts_dist_p = (/* unused pure expression or super */ null && ({
+  year: "yyyy",
+  month: "mm",
+  day: "dd"
+}));
+
+const group = async (o, r) => {
+  const t = {}, p = Object.keys(o);
+  for (const e of p) {
+    const i = o[e], n = await i({ results: t })?.catch((a) => {
+      throw a;
+    });
+    if (typeof r?.onCancel == "function" && isCancel(n)) {
+      t[e] = "canceled", r.onCancel({ results: t });
+      continue;
+    }
+    t[e] = n;
+  }
+  return t;
+};
+
+const MULTISELECT_INSTRUCTIONS = [
+  `${external_node_util_styleText("dim", "\u2191/\u2193")} to navigate`,
+  `${external_node_util_styleText("dim", "Space:")} select`,
+  `${external_node_util_styleText("dim", "Enter:")} confirm`
+];
+const prompts_dist_m = (i, u) => i.split(`
+`).map((d) => u(d)).join(`
+`);
+const multiselect = (i) => {
+  const u = (t, a) => {
+    const r = t.label ?? String(t.value);
+    return a === "disabled" ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${prompts_dist_m(r, (o) => styleText(["strikethrough", "gray"], o))}${t.hint ? ` ${styleText("dim", `(${t.hint ?? "disabled"})`)}` : ""}` : a === "active" ? `${styleText("cyan", S_CHECKBOX_ACTIVE)} ${r}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${prompts_dist_m(r, (o) => styleText("dim", o))}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "cancelled" ? `${prompts_dist_m(r, (o) => styleText(["strikethrough", "dim"], o))}` : a === "active-selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${r}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "submitted" ? `${prompts_dist_m(r, (o) => styleText("dim", o))}` : `${styleText("dim", S_CHECKBOX_INACTIVE)} ${prompts_dist_m(r, (o) => styleText("dim", o))}`;
+  }, d = i.required ?? true, v = i.showInstructions ?? true;
+  return new MultiSelectPrompt({
+    options: i.options,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValues: i.initialValues,
+    required: d,
+    cursorAt: i.cursorAt,
+    validate(t) {
+      if (d && (t === void 0 || t.length === 0))
+        return `Please select at least one option.
+${styleText(
+          "reset",
+          styleText(
+            "dim",
+            `Press ${styleText(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText(
+              "gray",
+              styleText("bgWhite", styleText("inverse", " enter "))
+            )} to submit`
+          )
+        )}`;
+    },
+    render() {
+      const t = i.withGuide ?? settings.withGuide, a = wrapTextWithPrefix(
+        i.output,
+        i.message,
+        t ? `${symbolBar(this.state)}  ` : "",
+        `${symbol(this.state)}  `
+      ), r = `${t ? `${styleText("gray", S_BAR)}
+` : ""}${a}
+`, o = this.value ?? [], p = (n, l) => {
+        if (n.disabled)
+          return u(n, "disabled");
+        const s = o.includes(n.value);
+        return l && s ? u(n, "active-selected") : s ? u(n, "selected") : u(n, l ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u(s, "submitted")).join(styleText("dim", ", ")) || styleText("dim", "none"), l = wrapTextWithPrefix(
+            i.output,
+            n,
+            t ? `${styleText("gray", S_BAR)}  ` : ""
+          );
+          return `${r}${l}`;
+        }
+        case "cancel": {
+          const n = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u(s, "cancelled")).join(styleText("dim", ", "));
+          if (n.trim() === "")
+            return `${r}${styleText("gray", S_BAR)}`;
+          const l = wrapTextWithPrefix(
+            i.output,
+            n,
+            t ? `${styleText("gray", S_BAR)}  ` : ""
+          );
+          return `${r}${l}${t ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const n = t ? `${styleText("yellow", S_BAR)}  ` : "", l = this.error.split(`
+`).map(
+            ($, C) => C === 0 ? `${t ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", $)}` : `   ${$}`
+          ).join(`
+`), s = r.split(`
+`).length, h = l.split(`
+`).length + 1;
+          return `${r}${n}${limitOptions({
+            output: i.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i.maxItems,
+            columnPadding: n.length,
+            rowPadding: s + h,
+            style: p
+          }).join(`
+${n}`)}
+${l}
+`;
+        }
+        default: {
+          const n = t ? `${styleText("cyan", S_BAR)}  ` : "", l = r.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t) : t ? [styleText("cyan", S_BAR_END)] : [], h = s.join(`
+`), $ = s.length + 1;
+          return `${r}${n}${limitOptions({
+            output: i.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i.maxItems,
+            columnPadding: n.length,
+            rowPadding: l + $,
+            style: p
+          }).join(`
+${n}`)}
+${h}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+
+const groupMultiselect = (o) => {
+  const { selectableGroups: h = true, groupSpacing: x = 0 } = o, m = (n, l, g = []) => {
+    const a = n.label ?? String(n.value), t = typeof n.group == "string", s = t && (g[g.indexOf(n) + 1] ?? { group: true }), u = t && s && s.group === true;
+    let r = "", c = "";
+    t && (h ? (r = u ? `${S_BAR_END} ` : `${S_BAR} `, c = u ? "  " : `${S_BAR} `) : r = "  ");
+    let i = "";
+    if (x > 0 && !t && (i = `
+`.repeat(x)), l === "active")
+      return wrapTextWithPrefix(
+        o.output,
+        `${a}${n.hint ? ` ${styleText("dim", `(${n.hint})`)}` : ""}`,
+        `${i}${styleText("dim", r)} `,
+        `${i}${styleText("dim", r)}${styleText("cyan", S_CHECKBOX_ACTIVE)} `,
+        `${i}${styleText("dim", c)} `
+      );
+    if (l === "group-active")
+      return wrapTextWithPrefix(
+        o.output,
+        a,
+        `${i}${r} `,
+        `${i}${r}${styleText("cyan", S_CHECKBOX_ACTIVE)} `,
+        `${i}${c} `,
+        (d) => styleText("dim", d)
+      );
+    if (l === "group-active-selected")
+      return wrapTextWithPrefix(
+        o.output,
+        a,
+        `${i}${r} `,
+        `${i}${r}${styleText("green", S_CHECKBOX_SELECTED)} `,
+        `${i}${c} `,
+        (d) => styleText("dim", d)
+      );
+    if (l === "selected") {
+      const d = t || h ? styleText("green", S_CHECKBOX_SELECTED) : "";
+      return wrapTextWithPrefix(
+        o.output,
+        `${a}${n.hint ? ` (${n.hint})` : ""}`,
+        `${i}${styleText("dim", r)} `,
+        `${i}${styleText("dim", r)}${d} `,
+        `${i}${styleText("dim", c)} `,
+        (S) => styleText("dim", S)
+      );
+    }
+    if (l === "cancelled")
+      return `${styleText(["strikethrough", "dim"], a)}`;
+    if (l === "active-selected")
+      return wrapTextWithPrefix(
+        o.output,
+        `${a}${n.hint ? ` ${styleText("dim", `(${n.hint})`)}` : ""}`,
+        `${i}${styleText("dim", r)} `,
+        `${i}${styleText("dim", r)}${styleText("green", S_CHECKBOX_SELECTED)} `,
+        `${i}${styleText("dim", c)} `
+      );
+    if (l === "submitted")
+      return `${styleText("dim", a)}`;
+    const f = t || h ? styleText("dim", S_CHECKBOX_INACTIVE) : "";
+    return wrapTextWithPrefix(
+      o.output,
+      a,
+      `${i}${styleText("dim", r)} `,
+      `${i}${styleText("dim", r)}${f} `,
+      `${i}${styleText("dim", c)} `,
+      (d) => styleText("dim", d)
+    );
+  }, y = o.required ?? true, I = o.showInstructions ?? true;
+  return new GroupMultiSelectPrompt({
+    options: o.options,
+    signal: o.signal,
+    input: o.input,
+    output: o.output,
+    initialValues: o.initialValues,
+    required: y,
+    cursorAt: o.cursorAt,
+    selectableGroups: h,
+    validate(n) {
+      if (y && (n === void 0 || n.length === 0))
+        return `Please select at least one option.
+${styleText(
+          "reset",
+          styleText(
+            "dim",
+            `Press ${styleText(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText(
+              "gray",
+              styleText(["bgWhite", "inverse"], " enter ")
+            )} to submit`
+          )
+        )}`;
+    },
+    render() {
+      const n = o.withGuide ?? settings.withGuide, l = `${n ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${o.message}
+`, g = this.value ?? [], a = (t, s) => {
+        const u = this.options, r = g.includes(t.value) || t.group === true && this.isGroupSelected(`${t.value}`);
+        return !s && typeof t.group == "string" && this.options[this.cursor]?.value === t.group ? m(t, r ? "group-active-selected" : "group-active", u) : s && r ? m(t, "active-selected", u) : r ? m(t, "selected", u) : m(t, s ? "active" : "inactive", u);
+      };
+      switch (this.state) {
+        case "submit": {
+          const t = this.options.filter(({ value: u }) => g.includes(u)).map((u) => m(u, "submitted")), s = t.length === 0 ? "" : `  ${t.join(styleText("dim", ", "))}`;
+          return `${l}${n ? styleText("gray", S_BAR) : ""}${s}`;
+        }
+        case "cancel": {
+          const t = this.options.filter(({ value: s }) => g.includes(s)).map((s) => m(s, "cancelled")).join(styleText("dim", ", "));
+          return `${l}${n ? `${styleText("gray", S_BAR)}  ` : ""}${t.trim() ? `${t}${n ? `
+${styleText("gray", S_BAR)}` : ""}` : ""}`;
+        }
+        case "error": {
+          const t = n ? `${styleText("yellow", S_BAR)}  ` : "", s = this.error.split(`
+`).map(
+            (i, f) => f === 0 ? `${n ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", i)}` : `   ${i}`
+          ).join(`
+`), u = l.split(`
+`).length, r = s.split(`
+`).length + 1, c = limitOptions({
+            output: o.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: o.maxItems,
+            columnPadding: t.length,
+            rowPadding: u + r,
+            style: a
+          }).join(`
+${t}`);
+          return `${l}${t}${c}
+${s}
+`;
+        }
+        default: {
+          const t = n ? `${styleText("cyan", S_BAR)}  ` : "", s = l.split(`
+`).length, u = I ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, n) : n ? [styleText("cyan", S_BAR_END)] : [], r = u.join(`
+`), c = u.length + 1, i = limitOptions({
+            output: o.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: o.maxItems,
+            columnPadding: t.length,
+            rowPadding: s + c,
+            style: a
+          }).join(`
+${t}`);
+          return `${l}${t}${i}
+${r}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+
+const log = {
+  message: (s = [], {
+    symbol: e = external_node_util_styleText("gray", S_BAR),
+    secondarySymbol: r = external_node_util_styleText("gray", S_BAR),
+    output: m = process.stdout,
+    spacing: l = 1,
+    withGuide: c
+  } = {}) => {
+    const t = [], o = c ?? dist_settings.withGuide, f = o ? r : "", O = o ? `${e}  ` : "", u = o ? `${r}  ` : "";
+    for (let i = 0; i < l; i++)
+      t.push(f);
+    const g = Array.isArray(s) ? s : s.split(`
+`);
+    if (g.length > 0) {
+      const [i, ...y] = g;
+      i.length > 0 ? t.push(`${O}${i}`) : t.push(o ? e : "");
+      for (const p of y)
+        p.length > 0 ? t.push(`${u}${p}`) : t.push(o ? r : "");
+    }
+    m.write(`${t.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: external_node_util_styleText("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: external_node_util_styleText("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: external_node_util_styleText("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: external_node_util_styleText("yellow", S_WARN) });
+  },
+  /** alias for `log.warn()`. */
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: external_node_util_styleText("red", S_ERROR) });
+  }
+};
+
+const cancel = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? dist_settings.withGuide ? `${external_node_util_styleText("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${external_node_util_styleText("red", o)}
+
+`);
+}, intro = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? dist_settings.withGuide ? `${external_node_util_styleText("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o}
+`);
+}, outro = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? dist_settings.withGuide ? `${external_node_util_styleText("gray", S_BAR)}
+${external_node_util_styleText("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o}
+
+`);
+};
+
+const multiline = (e) => new MultiLinePrompt({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  showSubmit: e.showSubmit,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i = e?.withGuide ?? settings.withGuide, o = `${`${i ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, m = e.placeholder && e.placeholder.length > 0 ? (
+      // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
+      styleText("inverse", e.placeholder[0]) + styleText("dim", e.placeholder.slice(1))
+    ) : styleText(["inverse", "hidden"], "_"), a = this.userInput ? this.userInputWithCursor : m, l = this.value ?? "", c = e.showSubmit ? `
+  ${styleText(this.focused === "submit" ? "cyan" : "dim", "[ submit ]")}` : "";
+    switch (this.state) {
+      case "error": {
+        const n = `${styleText("yellow", S_BAR)}  `, r = i ? wrapTextWithPrefix(e.output, a, n, void 0) : a, u = styleText("yellow", S_BAR_END);
+        return `${o}${r}
+${u}  ${styleText("yellow", this.error)}${c}
+`;
+      }
+      case "submit": {
+        const n = `${styleText("gray", S_BAR)}  `, r = i ? wrapTextWithPrefix(
+          e.output,
+          l,
+          n,
+          void 0,
+          void 0,
+          (u) => styleText("dim", u)
+        ) : l ? styleText("dim", l) : "";
+        return `${o}${r}`;
+      }
+      case "cancel": {
+        const n = `${styleText("gray", S_BAR)}  `, r = i ? wrapTextWithPrefix(
+          e.output,
+          l,
+          n,
+          void 0,
+          void 0,
+          (u) => styleText(["strikethrough", "dim"], u)
+        ) : l ? styleText(["strikethrough", "dim"], l) : "";
+        return `${o}${r}`;
+      }
+      default: {
+        const n = i ? `${styleText("cyan", S_BAR)}  ` : "", r = i ? styleText("cyan", S_BAR_END) : "", u = i ? wrapTextWithPrefix(e.output, a, n) : a;
+        return `${o}${u}
+${r}${c}
+`;
+      }
+    }
+  }
+}).prompt();
+
+const W$1 = (o) => o, prompts_dist_C = (o, e, s) => {
+  const a = {
+    hard: true,
+    trim: false
+  }, i = main_wrapAnsi(o, e, a).split(`
+`), c = i.reduce((n, t) => Math.max(fast_string_width_dist(t), n), 0), u = i.map(s).reduce((n, t) => Math.max(fast_string_width_dist(t), n), 0), g = e - (u - c);
+  return main_wrapAnsi(o, g, a);
+};
+const note = (o = "", e = "", s) => {
+  const a = s?.output ?? node_process.stdout, i = s?.withGuide ?? dist_settings.withGuide, c = s?.format ?? W$1, g = ["", ...prompts_dist_C(o, dist_getColumns(a) - 6, c).split(`
+`).map(c), ""], n = fast_string_width_dist(e), t = Math.max(
+    g.reduce((m, F) => {
+      const O = fast_string_width_dist(F);
+      return O > m ? O : m;
+    }, 0),
+    n
+  ) + 2, h = g.map(
+    (m) => `${external_node_util_styleText("gray", S_BAR)}  ${m}${" ".repeat(t - fast_string_width_dist(m))}${external_node_util_styleText("gray", S_BAR)}`
+  ).join(`
+`), T = i ? `${external_node_util_styleText("gray", S_BAR)}
+` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a.write(
+    `${T}${external_node_util_styleText("green", S_STEP_SUBMIT)}  ${external_node_util_styleText("reset", e)} ${external_node_util_styleText(
+      "gray",
+      S_BAR_H.repeat(Math.max(t - n - 1, 1)) + S_CORNER_TOP_RIGHT
+    )}
+${h}
+${external_node_util_styleText("gray", l$1 + S_BAR_H.repeat(t + 2) + S_CORNER_BOTTOM_RIGHT)}
+`
+  );
+};
+
+const dist_password = (r) => new PasswordPrompt({
+  validate: r.validate,
+  mask: r.mask ?? S_PASSWORD_MASK,
+  signal: r.signal,
+  input: r.input,
+  output: r.output,
+  render() {
+    const e = r.withGuide ?? settings.withGuide, o = `${e ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${r.message}
+`, c = this.userInputWithCursor, i = this.masked;
+    switch (this.state) {
+      case "error": {
+        const s = e ? `${styleText("yellow", S_BAR)}  ` : "", n = e ? `${styleText("yellow", S_BAR_END)}  ` : "", l = i ?? "";
+        return r.clearOnError && this.clear(), `${o.trim()}
+${s}${l}
+${n}${styleText("yellow", this.error)}
+`;
+      }
+      case "submit": {
+        const s = e ? `${styleText("gray", S_BAR)}  ` : "", n = i ? styleText("dim", i) : "";
+        return `${o}${s}${n}`;
+      }
+      case "cancel": {
+        const s = e ? `${styleText("gray", S_BAR)}  ` : "", n = i ? styleText(["strikethrough", "dim"], i) : "";
+        return `${o}${s}${n}${i && e ? `
+${styleText("gray", S_BAR)}` : ""}`;
+      }
+      default: {
+        const s = e ? `${styleText("cyan", S_BAR)}  ` : "", n = e ? styleText("cyan", S_BAR_END) : "";
+        return `${o}${s}${c}
+${n}
+`;
+      }
+    }
+  }
+}).prompt();
+
+const dist_path = (e) => {
+  const a = e.validate;
+  return autocomplete({
+    ...e,
+    initialUserInput: e.initialValue ?? e.root ?? process.cwd(),
+    maxItems: 5,
+    validate(t) {
+      if (!Array.isArray(t)) {
+        if (!t)
+          return "Please select a path";
+        if (a)
+          return runValidation(a, t);
+      }
+    },
+    options() {
+      const t = this.userInput;
+      if (t === "")
+        return [];
+      try {
+        let i;
+        existsSync(t) ? lstatSync(t).isDirectory() && (!e.directory || t.endsWith("/")) ? i = t : i = dirname(t) : i = dirname(t);
+        const c = t.length > 1 && t.endsWith("/") ? t.slice(0, -1) : t;
+        return readdirSync(i).map((r) => {
+          const n = join(i, r), m = lstatSync(n);
+          return {
+            name: r,
+            path: n,
+            isDirectory: m.isDirectory()
+          };
+        }).filter(
+          ({ path: r, isDirectory: n }) => r.startsWith(c) && (n || !e.directory)
+        ).map((r) => ({
+          value: r.path
+        }));
+      } catch {
+        return [];
+      }
+    }
+  });
+};
+
+const dist_W = (l) => styleText("magenta", l);
+const spinner = ({
+  indicator: l = "dots",
+  onCancel: h,
+  output: n = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m,
+  ...I
+} = {}) => {
+  const u = isCI();
+  let M, T, d = false, S = false, s = "", p, w = performance.now();
+  const x = getColumns(n), k = I?.styleFrame ?? dist_W, g = (e) => {
+    const r = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a(r, e), S && typeof h == "function" && h());
+  }, f = () => g(2), i = () => g(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i), process.on("SIGTERM", i), process.on("exit", g), m && m.addEventListener("abort", i);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f), process.removeListener("unhandledRejection", f), process.removeListener("SIGINT", i), process.removeListener("SIGTERM", i), process.removeListener("exit", g), m && m.removeEventListener("abort", i);
+  }, y = () => {
+    if (p === void 0) return;
+    u && n.write(`
+`);
+    const r = wrapAnsi(p, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r.length > 1 && n.write(cursor.up(r.length - 1)), n.write(cursor.to(0)), n.write(erase.down());
+  }, C = (e) => e.replace(/\.+$/, ""), _ = (e) => {
+    const r = (performance.now() - e) / 1e3, t = Math.floor(r / 60), o = Math.floor(r % 60);
+    return t > 0 ? `[${t}m ${o}s]` : `[${o}s]`;
+  }, N = I.withGuide ?? settings.withGuide, P = (e = "") => {
+    d = true, M = block({ output: n }), s = C(e), w = performance.now(), N && n.write(`${styleText("gray", S_BAR)}
+`);
+    let r = 0, t = 0;
+    A(), T = setInterval(() => {
+      if (u && s === p)
+        return;
+      y(), p = s;
+      const o = k(E[r]);
+      let v;
+      if (u)
+        v = `${o}  ${s}...`;
+      else if (l === "timer")
+        v = `${o}  ${s} ${_(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t)).slice(0, 3);
+        v = `${o}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n.write(j), r = r + 1 < E.length ? r + 1 : 0, t = t < 4 ? t + 0.125 : 0;
+    }, F);
+  }, a = (e = "", r = 0, t = false) => {
+    if (!d) return;
+    d = false, clearInterval(T), y();
+    const o = r === 0 ? styleText("green", S_STEP_SUBMIT) : r === 1 ? styleText("red", S_STEP_CANCEL) : styleText("red", S_STEP_ERROR);
+    s = e ?? s, t || (l === "timer" ? n.write(`${o}  ${s} ${_(w)}
+`) : n.write(`${o}  ${s}
+`)), H(), M();
+  };
+  return {
+    start: P,
+    stop: (e = "") => a(e, 0),
+    message: (e = "") => {
+      s = C(e ?? s);
+    },
+    cancel: (e = "") => a(e, 1),
+    error: (e = "") => a(e, 2),
+    clear: () => a("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+
+const prompts_dist_u = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+function progress({
+  style: o = "heavy",
+  max: d = 100,
+  size: v = 40,
+  ...x
+} = {}) {
+  const r = spinner(x);
+  let a = 0, n = "";
+  const c = Math.max(1, d), l = Math.max(1, v), S = (t) => {
+    switch (t) {
+      case "initial":
+      case "active":
+        return (e) => styleText("magenta", e);
+      case "error":
+      case "cancel":
+        return (e) => styleText("red", e);
+      case "submit":
+        return (e) => styleText("green", e);
+      default:
+        return (e) => styleText("magenta", e);
+    }
+  }, p = (t, e) => {
+    const m = Math.floor(a / c * l);
+    return `${S(t)(prompts_dist_u[o].repeat(m))}${styleText("dim", prompts_dist_u[o].repeat(l - m))} ${e}`;
+  }, h = (t = "") => {
+    n = t, r.start(p("initial", t));
+  }, g = (t = 1, e) => {
+    a = Math.min(c, t + a), r.message(p("active", e ?? n)), n = e ?? n;
+  };
+  return {
+    start: h,
+    stop: r.stop,
+    cancel: r.cancel,
+    error: r.error,
+    clear: r.clear,
+    advance: g,
+    isCancelled: r.isCancelled,
+    message: (t) => g(0, t)
+  };
+}
+
+const SELECT_INSTRUCTIONS = [
+  `${external_node_util_styleText("dim", "\u2191/\u2193")} to navigate`,
+  `${external_node_util_styleText("dim", "Enter:")} confirm`
+];
+const prompts_dist_c = (t, o) => t.includes(`
+`) ? t.split(`
+`).map((d) => o(d)).join(`
+`) : o(t);
+const dist_select = (t) => {
+  const o = (n, m) => {
+    if (n === void 0)
+      return "";
+    const s = n.label ?? String(n.value);
+    switch (m) {
+      case "disabled":
+        return `${external_node_util_styleText("gray", S_RADIO_INACTIVE)} ${prompts_dist_c(s, (i) => external_node_util_styleText("gray", i))}${n.hint ? ` ${external_node_util_styleText("dim", `(${n.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${prompts_dist_c(s, (i) => external_node_util_styleText("dim", i))}`;
+      case "active":
+        return `${external_node_util_styleText("green", S_RADIO_ACTIVE)} ${s}${n.hint ? ` ${external_node_util_styleText("dim", `(${n.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${prompts_dist_c(s, (i) => external_node_util_styleText(["strikethrough", "dim"], i))}`;
+      default:
+        return `${external_node_util_styleText("dim", S_RADIO_INACTIVE)} ${prompts_dist_c(s, (i) => external_node_util_styleText("dim", i))}`;
+    }
+  }, d = t.showInstructions ?? true;
+  return new n$1({
+    options: t.options,
+    signal: t.signal,
+    input: t.input,
+    output: t.output,
+    initialValue: t.initialValue,
+    render() {
+      const n = t.withGuide ?? dist_settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i = dist_wrapTextWithPrefix(
+        t.output,
+        t.message,
+        s,
+        m
+      ), u = `${n ? `${external_node_util_styleText("gray", S_BAR)}
+` : ""}${i}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r = n ? `${external_node_util_styleText("gray", S_BAR)}  ` : "", a = dist_wrapTextWithPrefix(
+            t.output,
+            o(this.options[this.cursor], "selected"),
+            r
+          );
+          return `${u}${a}`;
+        }
+        case "cancel": {
+          const r = n ? `${external_node_util_styleText("gray", S_BAR)}  ` : "", a = dist_wrapTextWithPrefix(
+            t.output,
+            o(this.options[this.cursor], "cancelled"),
+            r
+          );
+          return `${u}${a}${n ? `
+${external_node_util_styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r = n ? `${external_node_util_styleText("cyan", S_BAR)}  ` : "", a = u.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n) : n ? [external_node_util_styleText("cyan", S_BAR_END)] : [], b = p.join(`
+`), f = p.length + 1;
+          return `${u}${r}${limitOptions({
+            output: t.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t.maxItems,
+            columnPadding: r.length,
+            rowPadding: a + f,
+            style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r}`)}
+${b}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+
+const selectKey = (t) => {
+  const l = (e, a = "inactive") => {
+    if (e === void 0)
+      return "";
+    const n = e.label ?? String(e.value);
+    return a === "selected" ? `${styleText("dim", n)}` : a === "cancelled" ? `${styleText(["strikethrough", "dim"], n)}` : a === "active" ? `${styleText(["bgCyan", "gray"], ` ${e.value} `)} ${n}${e.hint ? ` ${styleText("dim", `(${e.hint})`)}` : ""}` : `${styleText(["gray", "bgWhite", "inverse"], ` ${e.value} `)} ${n}${e.hint ? ` ${styleText("dim", `(${e.hint})`)}` : ""}`;
+  };
+  return new SelectKeyPrompt({
+    options: t.options,
+    signal: t.signal,
+    input: t.input,
+    output: t.output,
+    initialValue: t.initialValue,
+    caseSensitive: t.caseSensitive,
+    render() {
+      const e = t.withGuide ?? settings.withGuide, a = `${e ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${t.message}
+`;
+      switch (this.state) {
+        case "submit": {
+          const n = e ? `${styleText("gray", S_BAR)}  ` : "", s = this.options.find((u) => u.value === this.value) ?? t.options[0], c = wrapTextWithPrefix(
+            t.output,
+            l(s, "selected"),
+            n
+          );
+          return `${a}${c}`;
+        }
+        case "cancel": {
+          const n = e ? `${styleText("gray", S_BAR)}  ` : "", s = wrapTextWithPrefix(
+            t.output,
+            l(this.options[0], "cancelled"),
+            n
+          );
+          return `${a}${s}${e ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const n = e ? `${styleText("cyan", S_BAR)}  ` : "", s = e ? styleText("cyan", S_BAR_END) : "", c = this.options.map(
+            (u, d) => wrapTextWithPrefix(
+              t.output,
+              l(u, d === this.cursor ? "active" : "inactive"),
+              n
+            )
+          ).join(`
+`);
+          return `${a}${c}
+${s}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+
+const dist_i = `${external_node_util_styleText("gray", S_BAR)}  `;
+const stream = (/* unused pure expression or super */ null && ({
+  message: async (e, { symbol: l = styleText("gray", S_BAR) } = {}) => {
+    process.stdout.write(`${styleText("gray", S_BAR)}
+${l}  `);
+    let s = 3;
+    for await (let r of e) {
+      r = r.replace(/\n/g, `
+${dist_i}`), r.includes(`
+`) && (s = 3 + stripVTControlCharacters(r.slice(r.lastIndexOf(`
+`))).length);
+      const o = stripVTControlCharacters(r).length;
+      s + o < process.stdout.columns ? (s += o, process.stdout.write(r)) : (process.stdout.write(`
+${dist_i}${r.trimStart()}`), s = 3 + stripVTControlCharacters(r.trimStart()).length);
+    }
+    process.stdout.write(`
+`);
+  },
+  info: (e) => stream.message(e, { symbol: styleText("blue", S_INFO) }),
+  success: (e) => stream.message(e, { symbol: styleText("green", S_SUCCESS) }),
+  step: (e) => stream.message(e, { symbol: styleText("green", S_STEP_SUBMIT) }),
+  warn: (e) => stream.message(e, { symbol: styleText("yellow", S_WARN) }),
+  /** alias for `log.warn()`. */
+  warning: (e) => stream.warn(e),
+  error: (e) => stream.message(e, { symbol: styleText("red", S_ERROR) })
+}));
+
+const tasks = async (o, e) => {
+  for (const t of o) {
+    if (t.enabled === false) continue;
+    const s = spinner(e);
+    s.start(t.title);
+    const n = await t.task(s.message);
+    s.stop(n || t.title);
+  }
+};
+
+const dist_A = (l) => l.replace(/\x1b\[(?:\d+;)*\d*[ABCDEFGHfJKSTsu]|\x1b\[(s|u)/g, "");
+const taskLog = (l) => {
+  const r = l.output ?? process.stdout, O = getColumns(r), i = styleText("gray", S_BAR), p = l.spacing ?? 1, k = 3, m = l.retainLog === true, d = !isCI() && isTTY(r);
+  r.write(`${i}
+`), r.write(`${styleText("green", S_STEP_SUBMIT)}  ${l.title}
+`);
+  for (let e = 0; e < p; e++)
+    r.write(`${i}
+`);
+  const n = [
+    {
+      value: "",
+      full: ""
+    }
+  ];
+  let v = false;
+  const f = (e) => {
+    if (n.length === 0)
+      return;
+    let s = 0;
+    e && (s += p + 2);
+    for (const t of n) {
+      const { value: o, result: a } = t;
+      let g = a?.message ?? o;
+      if (g.length === 0)
+        continue;
+      a === void 0 && t.header !== void 0 && t.header !== "" && (g += `
+${t.header}`);
+      const E = g.split(`
+`).reduce((b, w) => w === "" ? b + 1 : b + Math.ceil((w.length + k) / O), 0);
+      s += E;
+    }
+    s > 0 && (s += 1, r.write(erase.lines(s)));
+  }, h = (e, s, t) => {
+    const o = t ? `${e.full}
+${e.value}` : e.value;
+    e.header !== void 0 && e.header !== "" && log.message(
+      e.header.split(`
+`).map((a) => styleText("bold", a)),
+      {
+        output: r,
+        secondarySymbol: i,
+        symbol: i,
+        spacing: 0
+      }
+    ), log.message(
+      o.split(`
+`).map((a) => styleText("dim", a)),
+      {
+        output: r,
+        secondarySymbol: i,
+        symbol: i,
+        spacing: s ?? p
+      }
+    );
+  }, T = () => {
+    for (const e of n) {
+      const { header: s, value: t, full: o } = e;
+      (s === void 0 || s.length === 0) && t.length === 0 || h(e, void 0, m === true && o.length > 0);
+    }
+  }, L = (e, s, t) => {
+    if (f(false), (t?.raw !== true || !v) && e.value !== "" && (e.value += `
+`), e.value += dist_A(s), v = t?.raw === true, l.limit !== void 0) {
+      const o = e.value.split(`
+`), a = o.length - l.limit;
+      if (a > 0) {
+        const g = o.splice(0, a);
+        m && (e.full += (e.full === "" ? "" : `
+`) + g.join(`
+`));
+      }
+      e.value = o.join(`
+`);
+    }
+    d && y();
+  }, y = () => {
+    for (const e of n)
+      e.result ? e.result.status === "error" ? log.error(e.result.message, { output: r, secondarySymbol: i, spacing: 0 }) : log.success(e.result.message, { output: r, secondarySymbol: i, spacing: 0 }) : e.value !== "" && h(e, 0);
+  }, B = (e, s) => {
+    f(false), e.result = s, d && y();
+  };
+  return {
+    message(e, s) {
+      L(n[0], e, s);
+    },
+    group(e) {
+      const s = {
+        header: e,
+        value: "",
+        full: ""
+      };
+      return n.push(s), {
+        message(t, o) {
+          L(s, t, o);
+        },
+        error(t) {
+          B(s, {
+            status: "error",
+            message: t
+          });
+        },
+        success(t) {
+          B(s, {
+            status: "success",
+            message: t
+          });
+        }
+      };
+    },
+    error(e, s) {
+      f(true), log.error(e, { output: r, secondarySymbol: i, spacing: 1 }), s?.showLog !== false && T(), n.splice(1, n.length - 1), n[0].value = "", n[0].full = "";
+    },
+    success(e, s) {
+      f(true), log.success(e, { output: r, secondarySymbol: i, spacing: 1 }), s?.showLog === true && T(), n.splice(1, n.length - 1), n[0].value = "", n[0].full = "";
+    }
+  };
+};
+
+const dist_text = (e) => new dist_n({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i = e?.withGuide ?? dist_settings.withGuide, s = `${`${i ? `${external_node_util_styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, c = e.placeholder && e.placeholder.length > 0 ? (
+      // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
+      external_node_util_styleText("inverse", e.placeholder[0]) + external_node_util_styleText("dim", e.placeholder.slice(1))
+    ) : external_node_util_styleText(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : c, l = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n = this.error ? `  ${external_node_util_styleText("yellow", this.error)}` : "", r = i ? `${external_node_util_styleText("yellow", S_BAR)}  ` : "", d = i ? external_node_util_styleText("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r}${o}
+${d}${n}
+`;
+      }
+      case "submit": {
+        const n = l ? `  ${external_node_util_styleText("dim", l)}` : "", r = i ? external_node_util_styleText("gray", S_BAR) : "";
+        return `${s}${r}${n}`;
+      }
+      case "cancel": {
+        const n = l ? `  ${external_node_util_styleText(["strikethrough", "dim"], l)}` : "", r = i ? external_node_util_styleText("gray", S_BAR) : "";
+        return `${s}${r}${n}${l.trim() ? `
+${r}` : ""}`;
+      }
+      default: {
+        const n = i ? `${external_node_util_styleText("cyan", S_BAR)}  ` : "", r = i ? external_node_util_styleText("cyan", S_BAR_END) : "";
+        return `${s}${n}${o}
+${r}
+`;
+      }
+    }
+  }
+}).prompt();
+
+
+
+;// CONCATENATED MODULE: external "node:child_process"
+
+;// CONCATENATED MODULE: ./src/git.ts
+
+function git_git(args, cwd) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        shell: process.platform === 'win32'
+    });
+    return {
+        ok: result.status === 0,
+        stdout: (result.stdout ?? '').trim()
+    };
+}
+function hasGit(cwd) {
+    return git_git([
+        '--version'
+    ], cwd).ok;
+}
+/**
+ * Whether the new project already sits inside somebody's repository — scaffolding into a monorepo or an
+ * existing checkout, where a nested repo would be a surprise rather than a convenience.
+ */ function isInsideRepo(cwd) {
+    const { ok, stdout } = git_git([
+        'rev-parse',
+        '--is-inside-work-tree'
+    ], cwd);
+    return ok && stdout === 'true';
+}
+/**
+ * Initializes a repository and makes the first commit.
+ *
+ * `initialized` rather than `committed` is the honest answer when the commit itself fails, which it does
+ * on a machine with no `user.email` configured. That is not a reason to fail the scaffold — the files
+ * are all there and staged — so the caller reports it and moves on.
+ */ function initRepo(cwd) {
+    const init = git_git([
+        'init',
+        '-b',
+        'main'
+    ], cwd).ok || git_git([
+        'init'
+    ], cwd).ok;
+    if (!init) return 'failed';
+    if (!git_git([
+        'add',
+        '-A'
+    ], cwd).ok) return 'initialized';
+    return git_git([
+        'commit',
+        '-m',
+        'Initial commit from create-rshono'
+    ], cwd).ok ? 'committed' : 'initialized';
+}
+
+;// CONCATENATED MODULE: ./src/generated/framework.ts
+// GENERATED by scripts/codegen.mjs from packages/core — do not edit. Run `pnpm --filter @rshono/create codegen`.
+/** The framework release a scaffolded app is pinned to: this package and rshono ship together. */ const RSHONO_VERSION = '1.0.0-rc.0';
+/**
+ * The dependency versions rshono is tested against, copied from its own manifest. Exact where it is
+ * exact — React's RSC internals are coupled across builds, and a generated app has no workspace
+ * overrides to fall back on.
+ */ const FRAMEWORK_DEPS = {
+    hono: '^4.12.31',
+    react: '19.2.8',
+    'react-dom': '19.2.8',
+    typescript: '^7.0.2',
+    '@types/node': '^26.1.1',
+    '@types/react': '^19.2.17'
+};
+/** Every `deploy` target the installed framework knows, with the command that ships what it built. */ const DEPLOY_TARGETS = [
+    {
+        name: 'node',
+        hint: 'run `rshono start`'
+    },
+    {
+        name: 'cloudflare',
+        hint: 'deploy with `wrangler deploy`'
+    },
+    {
+        name: 'bun',
+        hint: 'run `bun dist/server/main.mjs`'
+    },
+    {
+        name: 'deno',
+        hint: 'run `deno serve -A dist/server/main.mjs`'
+    },
+    {
+        name: 'vercel',
+        hint: 'deploy with `vercel deploy --prebuilt`'
+    },
+    {
+        name: 'netlify',
+        hint: 'deploy with `netlify deploy --build=false --dir=.netlify/publish`'
+    },
+    {
+        name: 'aws-lambda',
+        hint: 'zip dist/ with the handler at dist/server/main.mjs'
+    }
+];
+
+;// CONCATENATED MODULE: ./src/options.ts
+
+const PACKAGE_MANAGERS = (/* unused pure expression or super */ null && ([
+    'npm',
+    'pnpm',
+    'yarn',
+    'bun'
+]));
+const DEPLOY_TARGET_NAMES = DEPLOY_TARGETS.map((target)=>target.name);
+function deployHint(name) {
+    return DEPLOY_TARGETS.find((target)=>target.name === name)?.hint ?? '';
+}
+function isDeployTarget(value) {
+    return DEPLOY_TARGET_NAMES.includes(value);
+}
+const QUALITY_PRESETS = [
+    {
+        id: 'prettier-oxlint',
+        label: 'Prettier + oxlint',
+        hint: 'the conventional formatter, with a fast linter',
+        formatter: 'prettier',
+        linter: 'oxlint'
+    },
+    {
+        id: 'biome',
+        label: 'Biome',
+        hint: 'formatter and linter in one tool',
+        formatter: 'biome',
+        linter: 'biome'
+    },
+    {
+        id: 'oxc',
+        label: 'oxfmt + oxlint',
+        hint: 'the oxc toolchain — fastest, newest',
+        formatter: 'oxfmt',
+        linter: 'oxlint'
+    },
+    {
+        id: 'none',
+        label: 'None',
+        hint: 'add your own later',
+        formatter: 'none',
+        linter: 'none'
+    }
+];
+/**
+ * Turns whatever the user typed into a name npm will accept, or returns `null` when nothing usable is
+ * left. Lowercasing and replacing runs of invalid characters covers the ordinary cases (`My App`,
+ * `my_app`); a scoped name is kept intact, since `@scope/name` is legal.
+ */ function toPackageName(input) {
+    const trimmed = input.trim().replace(/^\.\/+/, '').replace(/\/+$/, '');
+    if (!trimmed || trimmed === '.') return null;
+    // A scoped name is a name, not a path: `@scope/pkg` stays whole rather than becoming `pkg`. Anything
+    // else is a path, and the last segment is the one that names the project.
+    const scoped = /^@[^\\/]+[\\/][^\\/]+$/.test(trimmed);
+    const base = scoped ? trimmed : trimmed.split(/[\\/]/).filter(Boolean).pop() ?? '';
+    if (!base) return null;
+    const name = base.toLowerCase().replace(/[\\/]/g, '/').replace(/[^a-z\d\-._~/@]+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
+    if (!name || name === '@' || !scoped && name.startsWith('.')) return null;
+    return name.slice(0, 214);
+}
+/** npm's own rule, narrowed to what we ever generate: no uppercase, no leading dot or underscore. */ function isValidPackageName(name) {
+    return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(name) && name.length <= 214;
+}
+
+;// CONCATENATED MODULE: ./src/features/combinations.ts
+/**
+ * Biome's CSS parser rejects Tailwind's syntax — `@apply` and a `@layer` block are parse errors, not
+ * unknown-at-rule warnings — so a project with both needs Biome pointed away from stylesheets. The
+ * overlay is a second `biome.json` listed after the first, which is all "later overlay wins" means.
+ *
+ * Narrow on purpose: the alternative was excluding CSS for everybody, which would quietly give up
+ * formatting the plain-CSS template that Biome handles perfectly well.
+ */ const BIOME_TAILWIND = {
+    id: 'biome-tailwind',
+    overlays: [
+        'biome-tailwind'
+    ]
+};
+/**
+ * Features that exist because of how two answers *combine*, rather than because of either one alone.
+ * Applied after the per-axis features, so an overlay here has the last word on a file.
+ *
+ * Keep this list short. A combination that needs more than a file swap is usually a sign that the two
+ * options should not both be offered.
+ */ function combinationFeatures(answers) {
+    const usesBiome = answers.formatter === 'biome' || answers.linter === 'biome';
+    return usesBiome && answers.styling === 'tailwind' ? [
+        BIOME_TAILWIND
+    ] : [];
+}
+
+;// CONCATENATED MODULE: ./src/versions.ts
+
+
+/** The framework range a scaffolded app gets. The two packages are released together, so this is ours. */ const RSHONO_RANGE = `^${RSHONO_VERSION}`;
+/**
+ * Versions for the optional tooling the features can add — the one place in this package where a
+ * dependency range is typed out by hand, because none of these are things the framework itself
+ * declares. Everything a *scaffolded app* needs to run rshono comes from {@link FRAMEWORK_DEPS},
+ * which is generated from rshono's own manifest and must not be edited here.
+ *
+ * Ranges are caret, not exact: these are the app's own dev tools, and a scaffold made six months from
+ * now should pick up their patch releases rather than pinning whatever was current the day this file
+ * was last touched.
+ */ const TOOL_VERSIONS = {
+    tailwindcss: '^4.3.3',
+    '@tailwindcss/postcss': '^4.3.3',
+    // The pass Tailwind runs in, installed with it rather than with the framework.
+    postcss: '^8.5.23',
+    'postcss-loader': '^8.2.1',
+    prettier: '^3.9.6',
+    '@biomejs/biome': '^2.5.6',
+    oxlint: '^1.76.0',
+    oxfmt: '^0.61.0',
+    wrangler: '^4.115.0'
+};
+
+;// CONCATENATED MODULE: ./src/features/deploy.ts
+
+/**
+ * What a deploy target adds beyond the `deploy` line in `rshono.config.ts` — which is the build's job
+ * to read, and the template's to carry.
+ *
+ * Deliberately thin. The framework already knows how to arrange its own output for every platform, and
+ * `rshono build` writes the one platform config that has to exist (`wrangler.jsonc`, with the
+ * `compatibility_date` of the day it ran) if the project has none. Generating a second copy here would
+ * be a copy that goes stale. So a target contributes a `deploy` script, the CLI it needs locally, and
+ * the build artefacts its platform leaves in the project.
+ */ const DEPLOY_FEATURES = {
+    // Where a Node build goes from here is a Dockerfile or a process manager, neither of which this can
+    // guess — so the target contributes only the command that runs what was built.
+    node: {
+        id: 'deploy-node',
+        scripts: {
+            start: 'rshono start'
+        }
+    },
+    // `rshono start` is the Node target's launcher and refuses a build made for another platform, so
+    // these two get the command their own runtime uses under the same script name.
+    bun: {
+        id: 'deploy-bun',
+        scripts: {
+            start: 'bun dist/server/main.mjs'
+        }
+    },
+    deno: {
+        id: 'deploy-deno',
+        scripts: {
+            start: 'deno serve -A dist/server/main.mjs'
+        }
+    },
+    cloudflare: {
+        id: 'deploy-cloudflare',
+        devDependencies: {
+            wrangler: TOOL_VERSIONS.wrangler
+        },
+        scripts: {
+            deploy: 'rshono build && wrangler deploy'
+        },
+        gitignore: [
+            '.wrangler/'
+        ],
+        notes: [
+            'The first build writes wrangler.jsonc — yours to edit after that.'
+        ]
+    },
+    vercel: {
+        id: 'deploy-vercel',
+        scripts: {
+            deploy: 'rshono build && vercel deploy --prebuilt'
+        },
+        gitignore: [
+            '.vercel/'
+        ],
+        notes: [
+            '--prebuilt uploads what rshono build assembled; the platform must not rebuild it.'
+        ]
+    },
+    netlify: {
+        id: 'deploy-netlify',
+        scripts: {
+            deploy: 'rshono build && netlify deploy --build=false --dir=.netlify/publish'
+        },
+        gitignore: [
+            '.netlify/'
+        ]
+    },
+    'aws-lambda': {
+        id: 'deploy-aws-lambda',
+        notes: [
+            'Use a Function URL in RESPONSE_STREAM mode — a buffered invoke mode drops the streaming.'
+        ]
+    }
+};
+function deployFeature(target) {
+    return DEPLOY_FEATURES[target];
+}
+
+;// CONCATENATED MODULE: ./src/features/quality.ts
+
+/**
+ * The formatter and linter features. Biome answers to both slots and appears once — `selectFeatures`
+ * deduplicates by `id`, so `formatter: 'biome', linter: 'biome'` contributes one set of files, one
+ * dependency and one pair of scripts.
+ *
+ * Each tool brings its own `check` script alongside `format`/`lint`, because the writing half and the
+ * CI half want different exit-code behaviour: `format` rewrites files, `check` fails instead.
+ */ const PRETTIER = {
+    id: 'prettier',
+    overlays: [
+        'prettier'
+    ],
+    devDependencies: {
+        prettier: TOOL_VERSIONS.prettier
+    },
+    scripts: {
+        format: 'prettier --write .',
+        'format:check': 'prettier --check .'
+    }
+};
+const OXFMT = {
+    id: 'oxfmt',
+    overlays: [
+        'oxfmt'
+    ],
+    devDependencies: {
+        oxfmt: TOOL_VERSIONS.oxfmt
+    },
+    scripts: {
+        format: 'oxfmt .',
+        'format:check': 'oxfmt --check .'
+    }
+};
+const OXLINT = {
+    id: 'oxlint',
+    overlays: [
+        'oxlint'
+    ],
+    devDependencies: {
+        oxlint: TOOL_VERSIONS.oxlint
+    },
+    scripts: {
+        lint: 'oxlint',
+        'lint:fix': 'oxlint --fix'
+    }
+};
+const BIOME = {
+    id: 'biome',
+    overlays: [
+        'biome'
+    ],
+    devDependencies: {
+        '@biomejs/biome': TOOL_VERSIONS["@biomejs/biome"]
+    },
+    scripts: {
+        format: 'biome format --write .',
+        'format:check': 'biome format .',
+        lint: 'biome lint .',
+        'lint:fix': 'biome lint --write .',
+        check: 'biome check .'
+    }
+};
+const FORMATTERS = {
+    prettier: PRETTIER,
+    oxfmt: OXFMT,
+    biome: BIOME,
+    none: null
+};
+const LINTERS = {
+    oxlint: OXLINT,
+    biome: BIOME,
+    none: null
+};
+function formatterFeature(formatter) {
+    return FORMATTERS[formatter];
+}
+function linterFeature(linter) {
+    return LINTERS[linter];
+}
+
+;// CONCATENATED MODULE: ./src/features/styling.ts
+
+/**
+ * Tailwind is a PostCSS plugin and nothing more, which is the whole of this feature: four packages, and
+ * an overlay carrying the `postcss.config.mjs` naming the plugin, an `rshono.config.ts` whose `rspack`
+ * hook puts postcss-loader in front of the CSS parser, a Tailwind entry stylesheet, and the two views
+ * written in utilities instead of classes of their own.
+ *
+ * `postcss` and `postcss-loader` are the app's dependencies rather than the framework's — rshono
+ * compiles CSS natively and has no PostCSS in it, so an app that does not want a plugin chain does not
+ * install one.
+ */ const TAILWIND = {
+    id: 'tailwind',
+    overlays: [
+        'tailwind'
+    ],
+    devDependencies: {
+        tailwindcss: TOOL_VERSIONS.tailwindcss,
+        '@tailwindcss/postcss': TOOL_VERSIONS["@tailwindcss/postcss"],
+        postcss: TOOL_VERSIONS.postcss,
+        'postcss-loader': TOOL_VERSIONS["postcss-loader"]
+    }
+};
+function stylingFeature(styling) {
+    return styling === 'tailwind' ? TAILWIND : null;
+}
+
+;// CONCATENATED MODULE: ./src/features/index.ts
+
+
+
+
+/**
+ * The features a set of answers selects, in application order — so an overlay listed later wins a file
+ * both of them ship. Deduplicated by `id`, which is what lets one feature answer two questions (Biome
+ * is both the formatter and the linter) without contributing twice.
+ */ function selectFeatures(answers) {
+    const selected = [
+        deployFeature(answers.deploy),
+        stylingFeature(answers.styling),
+        formatterFeature(answers.formatter),
+        linterFeature(answers.linter),
+        ...combinationFeatures(answers)
+    ];
+    const features = [];
+    const seen = new Set();
+    for (const feature of selected){
+        if (!feature || seen.has(feature.id)) continue;
+        seen.add(feature.id);
+        features.push(feature);
+    }
+    return features;
+}
+
+;// CONCATENATED MODULE: ./src/pkg.ts
+
+/**
+ * The scripts every app gets. `start` is not among them: it is the *Node* launcher, and the deploy
+ * features each contribute the command their own platform runs what was built with.
+ */ const BASE_SCRIPTS = {
+    dev: 'rshono dev',
+    build: 'rshono build',
+    typecheck: 'tsc --noEmit'
+};
+/** Field order in the emitted file — the conventional reading order, and stable so snapshots are too. */ const FIELD_ORDER = [
+    'name',
+    'version',
+    'private',
+    'type',
+    'engines',
+    'packageManager',
+    'scripts',
+    'dependencies',
+    'devDependencies'
+];
+function sorted(record) {
+    return Object.fromEntries(Object.entries(record).sort(([a], [b])=>a < b ? -1 : 1));
+}
+/**
+ * Assembles `package.json` from the answers and whatever the selected features contribute.
+ *
+ * Dependencies are sorted by name and scripts are left in contribution order (the base ones, then each
+ * feature's, in the order features were selected) — so two runs with the same answers produce byte-
+ * identical output, which is what makes the generated manifest snapshot-testable.
+ */ function buildPackageJson(answers, features, pm) {
+    const scripts = {
+        ...BASE_SCRIPTS
+    };
+    const dependencies = {
+        '@rshono/core': RSHONO_RANGE,
+        hono: FRAMEWORK_DEPS.hono,
+        react: FRAMEWORK_DEPS.react,
+        'react-dom': FRAMEWORK_DEPS["react-dom"]
+    };
+    const devDependencies = {
+        '@types/node': FRAMEWORK_DEPS["@types/node"],
+        '@types/react': FRAMEWORK_DEPS["@types/react"],
+        typescript: FRAMEWORK_DEPS.typescript
+    };
+    for (const feature of features){
+        Object.assign(scripts, feature.scripts);
+        Object.assign(dependencies, feature.dependencies);
+        Object.assign(devDependencies, feature.devDependencies);
+    }
+    const manifest = {
+        name: answers.packageName,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        // The floor the framework declares. Stated here too so a CI image or a contributor on an older
+        // Node finds out from their package manager rather than from a stack trace.
+        engines: {
+            node: '>=22.1.0'
+        },
+        scripts,
+        dependencies: sorted(dependencies),
+        devDependencies: sorted(devDependencies)
+    };
+    // Only when the environment told us the exact version: `packageManager` pins the tool for Corepack,
+    // and a guess at the version is worse than leaving the field out.
+    if (pm.version) manifest.packageManager = `${pm.name}@${pm.version}`;
+    const ordered = Object.fromEntries(FIELD_ORDER.filter((field)=>field in manifest).map((field)=>[
+            field,
+            manifest[field]
+        ]));
+    return `${JSON.stringify(ordered, null, 2)}\n`;
+}
+
+;// CONCATENATED MODULE: ./src/render.ts
+
+const TOKEN_PATTERN = /__[A-Z][A-Z\d_]*__/g;
+function tokensFor(answers, pm) {
+    return {
+        __PROJECT_NAME__: answers.packageName,
+        __DEPLOY_TARGET__: answers.deploy,
+        __DEPLOY_HINT__: deployHint(answers.deploy),
+        __PM__: pm.name,
+        __PM_RUN__: pm.run
+    };
+}
+/**
+ * Substitutes tokens, and throws on one it doesn't know — a typo in a template would otherwise ship a
+ * literal `__PORJECT_NAME__` into somebody's new app, which no test of the generator's logic would
+ * catch.
+ */ function render(contents, tokens, source) {
+    return contents.replace(TOKEN_PATTERN, (token)=>{
+        const value = tokens[token];
+        if (value === undefined) throw new Error(`[create-rshono] ${source} uses unknown template token ${token}`);
+        return value;
+    });
+}
+
+;// CONCATENATED MODULE: ./src/plan.ts
+
+
+
+
+
+/** `dist/cli.mjs` and `templates/` are siblings in the published package, as they are in the repo. */ const TEMPLATES_DIR = external_node_path_join(__rspack_import_meta_dirname__, '..', 'templates');
+function readTemplateDir(dir) {
+    const files = new Map();
+    for (const entry of external_node_fs_readdirSync(dir, {
+        recursive: true,
+        withFileTypes: true
+    })){
+        if (!entry.isFile()) continue;
+        const absolute = external_node_path_join(entry.parentPath, entry.name);
+        const relative = absolute.slice(dir.length + 1).split(sep).join(posix.sep);
+        files.set(relative, readFileSync(absolute, 'utf8'));
+    }
+    return files;
+}
+/**
+ * `_gitignore` → `.gitignore`, and so on for every dotfile.
+ *
+ * npm strips a literal `.gitignore` out of a published tarball, so a template cannot simply contain
+ * one — the file would exist in the repo, pass every local test, and be missing from the package
+ * everybody actually installs. Naming them with an underscore and renaming here is the long-standing
+ * fix. It applies to the basename only, so `src/lib/_x.ts` is a dotfile but `templates/_x/y.ts` is not.
+ */ function undotted(path) {
+    const segments = path.split(posix.sep);
+    const name = segments.pop();
+    return [
+        ...segments,
+        name.startsWith('_') ? `.${name.slice(1)}` : name
+    ].join(posix.sep);
+}
+/**
+ * A feature's `.gitignore` lines, appended under a heading naming it — so somebody reading the file six
+ * months later can tell why `.wrangler/` is in there.
+ */ function appendGitignore(existing, features) {
+    const additions = features.filter((feature)=>feature.gitignore?.length);
+    if (additions.length === 0) return existing;
+    const blocks = additions.map((feature)=>`\n# ${feature.id}\n${feature.gitignore.join('\n')}\n`);
+    return existing + blocks.join('');
+}
+/**
+ * Turns answers into the exact set of files to write, without touching the target directory — the
+ * decisions and the I/O are separated so the whole matrix of answers can be asserted on in a test, and
+ * so `--dry-run` is the same code path minus the last step.
+ */ function plan_plan(answers, pm) {
+    const features = selectFeatures(answers);
+    const tokens = tokensFor(answers, pm);
+    const raw = readTemplateDir(external_node_path_join(TEMPLATES_DIR, 'base'));
+    for (const feature of features){
+        for (const overlay of feature.overlays ?? []){
+            for (const [path, contents] of readTemplateDir(external_node_path_join(TEMPLATES_DIR, overlay))){
+                raw.set(path, contents);
+            }
+        }
+    }
+    const files = new Map();
+    for (const [path, contents] of raw){
+        files.set(undotted(path), render(contents, tokens, path));
+    }
+    const gitignore = files.get('.gitignore');
+    if (gitignore) files.set('.gitignore', appendGitignore(gitignore, features));
+    files.set('package.json', buildPackageJson(answers, features, pm));
+    return {
+        // Sorted, so both the write order and a test's snapshot are stable.
+        files: new Map([
+            ...files
+        ].sort(([a], [b])=>a < b ? -1 : 1)),
+        features,
+        notes: features.flatMap((feature)=>feature.notes ?? [])
+    };
+}
+
+;// CONCATENATED MODULE: ./src/pm.ts
+
+const INSTALL = {
+    npm: [
+        'install'
+    ],
+    pnpm: [
+        'install'
+    ],
+    yarn: [],
+    bun: [
+        'install'
+    ]
+};
+const RUN = {
+    npm: 'npm run',
+    pnpm: 'pnpm',
+    yarn: 'yarn',
+    bun: 'bun'
+};
+function isKnown(name) {
+    return name === 'npm' || name === 'pnpm' || name === 'yarn' || name === 'bun';
+}
+function packageManager(name, version) {
+    return {
+        name,
+        version,
+        install: INSTALL[name],
+        run: RUN[name]
+    };
+}
+/**
+ * Which package manager invoked us. Every one of them sets `npm_config_user_agent` for the process it
+ * spawns — `pnpm/11.9.0 npm/? node/v22.14.0 darwin arm64` — so `pnpm create @rshono` scaffolds a pnpm
+ * project without asking, and the exact version comes along for the `packageManager` field.
+ *
+ * Falls back to npm, which is also what a bare `node bin/create-rshono.mjs` gets.
+ */ function detectPackageManager(userAgent = process.env.npm_config_user_agent) {
+    const [spec] = (userAgent ?? '').split(' ');
+    const [name, version] = (spec ?? '').split('/');
+    if (name && isKnown(name)) return packageManager(name, version && /^\d+\.\d+\.\d+/.test(version) ? version : undefined);
+    return packageManager('npm');
+}
+/**
+ * Runs the install, streaming its output. `shell: true` on Windows because npm, pnpm and yarn are all
+ * `.cmd` shims there, which `spawn` cannot execute directly — and with a shell involved the arguments
+ * are all fixed strings from the tables above, never anything the user typed.
+ */ function runInstall(pm, cwd) {
+    return run(pm, pm.install, cwd);
+}
+/** `<pm> run <script>` — the one form every package manager accepts, Yarn v1 included. */ function runScript(pm, script, cwd) {
+    return run(pm, [
+        'run',
+        script
+    ], cwd);
+}
+function run(pm, args, cwd) {
+    const result = spawnSync(pm.name, args, {
+        cwd,
+        stdio: 'inherit',
+        shell: process.platform === 'win32'
+    });
+    return result.status === 0;
+}
+
+;// CONCATENATED MODULE: ./src/ui.ts
+
+
+/**
+ * What to do next, in the order to do it — the last thing the user reads, and for most people the only
+ * documentation they will read today. `installed` decides whether the install step is still theirs.
+ */ function nextSteps(answers, plan, pm, options) {
+    const steps = [];
+    if (options.directory !== '.') steps.push(`cd ${options.directory}`);
+    if (!options.installed) steps.push(`${pm.name}${pm.install.length > 0 ? ` ${pm.install.join(' ')}` : ''}`);
+    steps.push(`${pm.run} dev`);
+    const lines = [
+        steps.join('\n')
+    ];
+    lines.push(`\nThen ${pm.run} build, and ${deployHint(answers.deploy)}.`);
+    if (plan.notes.length > 0) lines.push(`\n${plan.notes.join('\n')}`);
+    return lines.join('\n');
+}
+/** The one-line summary of what was chosen, for the run that answered everything from flags. */ function summary(answers) {
+    const quality = [
+        answers.formatter,
+        answers.linter === answers.formatter ? null : answers.linter
+    ].filter((part)=>part && part !== 'none');
+    return [
+        `deploy: ${answers.deploy}`,
+        `styling: ${answers.styling === 'tailwind' ? 'Tailwind CSS' : 'plain CSS'}`,
+        `quality: ${quality.length > 0 ? quality.join(' + ') : 'none'}`
+    ].join('  ·  ');
+}
+/** A cancelled prompt ends the run, rather than falling through to a default the user did not pick. */ function unwrap(value) {
+    if (dist_isCancel(value)) {
+        cancel('Cancelled — nothing was written.');
+        process.exit(130);
+    }
+    return value;
+}
+
+;// CONCATENATED MODULE: ./src/write.ts
+
+
+/**
+ * Files that do not make a directory "occupied". A user who ran `git init` or opened the folder in an
+ * editor before scaffolding has not put anything in it that we would overwrite.
+ */ const IGNORED_ENTRIES = new Set([
+    '.git',
+    '.DS_Store',
+    '.idea',
+    '.vscode',
+    'Thumbs.db'
+]);
+function inspectTarget(dir) {
+    if (!external_node_fs_existsSync(dir)) return {
+        exists: false,
+        conflicts: []
+    };
+    return {
+        exists: true,
+        conflicts: external_node_fs_readdirSync(dir).filter((entry)=>!IGNORED_ENTRIES.has(entry))
+    };
+}
+/**
+ * Writes the plan. Directories are created as needed, and files are written with the plan's own
+ * ordering so a failure part-way through leaves something a person can make sense of.
+ */ function writePlan(plan, targetDir) {
+    mkdirSync(targetDir, {
+        recursive: true
+    });
+    for (const [path, contents] of plan.files){
+        const absolute = external_node_path_join(targetDir, path);
+        mkdirSync(external_node_path_dirname(absolute), {
+            recursive: true
+        });
+        writeFileSync(absolute, contents);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/cli.ts
+
+
+
+
+
+
+
+
+
+const DEFAULT_DIRECTORY = 'my-rshono-app';
+const HELP = `create-rshono — scaffold a new rshono app
+
+Usage:
+  npm create @rshono@latest [directory] [options]
+
+Options:
+  -y, --yes                accept the default for every question not given as a flag
+  -d, --deploy <target>    ${DEPLOY_TARGET_NAMES.join(' | ')}
+      --tailwind           Tailwind CSS (--no-tailwind for plain CSS)
+      --quality <preset>   ${QUALITY_PRESETS.map((preset)=>preset.id).join(' | ')}
+      --formatter <name>   prettier | biome | oxfmt | none  (overrides --quality)
+      --linter <name>      oxlint | biome | none            (overrides --quality)
+      --pm <name>          npm | pnpm | yarn | bun          (default: whatever ran this)
+      --no-install         write the files and stop
+      --no-git             do not initialize a repository
+      --force              scaffold into a directory that is not empty
+      --dry-run            list the files that would be written, and write nothing
+  -h, --help               show this help
+  -v, --version            print the version
+
+Every question can be answered by a flag, and a non-interactive terminal implies --yes — so one command
+scaffolds without prompting:
+
+  npm create @rshono@latest my-app -y --deploy cloudflare --tailwind --quality biome
+`;
+function fail(message) {
+    log.error(message);
+    process.exit(1);
+}
+/** A flag's value, checked against what the option accepts — a typo should not become a silent default. */ function oneOf(value, allowed, flag) {
+    if (value === undefined) return undefined;
+    if (!allowed.includes(value)) fail(`--${flag} must be one of: ${allowed.join(', ')} (got "${value}")`);
+    return value;
+}
+/** `--x` / `--no-x` pairs, since `parseArgs` has no notion of a negatable boolean. */ function tristate(on, off, flag) {
+    if (on && off) fail(`--${flag} and --no-${flag} contradict each other.`);
+    if (on) return true;
+    if (off) return false;
+    return undefined;
+}
+async function main() {
+    const { values, positionals } = parseArgs({
+        options: {
+            yes: {
+                type: 'boolean',
+                short: 'y'
+            },
+            deploy: {
+                type: 'string',
+                short: 'd'
+            },
+            tailwind: {
+                type: 'boolean'
+            },
+            'no-tailwind': {
+                type: 'boolean'
+            },
+            quality: {
+                type: 'string'
+            },
+            formatter: {
+                type: 'string'
+            },
+            linter: {
+                type: 'string'
+            },
+            pm: {
+                type: 'string'
+            },
+            install: {
+                type: 'boolean'
+            },
+            'no-install': {
+                type: 'boolean'
+            },
+            git: {
+                type: 'boolean'
+            },
+            'no-git': {
+                type: 'boolean'
+            },
+            force: {
+                type: 'boolean'
+            },
+            'dry-run': {
+                type: 'boolean'
+            },
+            help: {
+                type: 'boolean',
+                short: 'h'
+            },
+            version: {
+                type: 'boolean',
+                short: 'v'
+            }
+        },
+        allowPositionals: true
+    });
+    if (values.help) return console.log(HELP);
+    if (values.version) return console.log("1.0.0-rc.0");
+    // A pipe, a CI job or an agent gets the defaults rather than a prompt nothing can answer.
+    const interactive = Boolean(process.stdout.isTTY) && !values.yes;
+    const pmFlag = oneOf(values.pm, [
+        'npm',
+        'pnpm',
+        'yarn',
+        'bun'
+    ], 'pm');
+    const pm = pmFlag ? packageManager(pmFlag) : detectPackageManager();
+    const deployFlag = oneOf(values.deploy, DEPLOY_TARGET_NAMES, 'deploy');
+    const formatterFlag = oneOf(values.formatter, [
+        'prettier',
+        'biome',
+        'oxfmt',
+        'none'
+    ], 'formatter');
+    const linterFlag = oneOf(values.linter, [
+        'oxlint',
+        'biome',
+        'none'
+    ], 'linter');
+    const qualityFlag = oneOf(values.quality, QUALITY_PRESETS.map((preset)=>preset.id), 'quality');
+    const tailwindFlag = tristate(values.tailwind, values['no-tailwind'], 'tailwind');
+    const installFlag = tristate(values.install, values['no-install'], 'install');
+    const gitFlag = tristate(values.git, values['no-git'], 'git');
+    intro(`create-rshono  ·  rshono ${"1.0.0-rc.0"}`);
+    // ── Where ───────────────────────────────────────────────────────────────────────────────────────
+    let directory = positionals[0];
+    if (!directory) {
+        directory = interactive ? unwrap(await dist_text({
+            message: 'Where should the app go?',
+            placeholder: DEFAULT_DIRECTORY,
+            defaultValue: DEFAULT_DIRECTORY,
+            validate: (value)=>toPackageName(value || DEFAULT_DIRECTORY) ? undefined : 'That leaves nothing usable as a package name.'
+        })) : DEFAULT_DIRECTORY;
+    }
+    const targetDir = resolve(process.cwd(), directory);
+    const packageName = toPackageName(directory === '.' ? basename(targetDir) : directory);
+    if (!packageName || !isValidPackageName(packageName)) fail(`"${directory}" does not give a usable npm package name.`);
+    const conflicts = inspectTarget(targetDir).conflicts;
+    if (conflicts.length > 0 && !values.force) {
+        const where = directory === '.' ? 'this directory' : `"${directory}"`;
+        const listed = `${conflicts.slice(0, 3).join(', ')}${conflicts.length > 3 ? ', …' : ''}`;
+        if (!interactive) fail(`${where} is not empty (${listed}) — pass --force to scaffold into it anyway.`);
+        const proceed = unwrap(await dist_confirm({
+            message: `${where} is not empty (${listed}). Write into it anyway?`,
+            initialValue: false
+        }));
+        if (!proceed) {
+            cancel('Nothing was written.');
+            process.exit(0);
+        }
+    }
+    // ── What ────────────────────────────────────────────────────────────────────────────────────────
+    let deploy = deployFlag ?? 'node';
+    if (!deployFlag && interactive) {
+        deploy = unwrap(await dist_select({
+            message: 'Where will it be deployed?',
+            initialValue: deploy,
+            options: DEPLOY_TARGET_NAMES.map((name)=>({
+                    value: name,
+                    label: name
+                }))
+        }));
+    }
+    let styling = tailwindFlag === undefined ? 'css' : tailwindFlag ? 'tailwind' : 'css';
+    if (tailwindFlag === undefined && interactive) {
+        styling = unwrap(await dist_select({
+            message: 'Styling?',
+            initialValue: styling,
+            options: [
+                {
+                    value: 'css',
+                    label: 'Plain CSS',
+                    hint: 'compiled natively, no PostCSS'
+                },
+                {
+                    value: 'tailwind',
+                    label: 'Tailwind CSS',
+                    hint: 'adds postcss.config.mjs'
+                }
+            ]
+        }));
+    }
+    /*
+   * The preset asks one question instead of two. The two axes stay independent underneath — a
+   * `--formatter` or `--linter` flag addresses either on its own, and skips the question entirely.
+   */ let preset = QUALITY_PRESETS.find((candidate)=>candidate.id === qualityFlag);
+    if (!preset && !formatterFlag && !linterFlag) {
+        const fallback = QUALITY_PRESETS["0"];
+        if (interactive) {
+            const id = unwrap(await dist_select({
+                message: 'Formatting and linting?',
+                initialValue: fallback.id,
+                options: QUALITY_PRESETS.map((option)=>({
+                        value: option.id,
+                        label: option.label,
+                        hint: option.hint
+                    }))
+            }));
+            preset = QUALITY_PRESETS.find((candidate)=>candidate.id === id);
+        } else {
+            preset = fallback;
+        }
+    }
+    const formatter = formatterFlag ?? preset?.formatter ?? 'none';
+    const linter = linterFlag ?? preset?.linter ?? 'none';
+    // ── How ─────────────────────────────────────────────────────────────────────────────────────────
+    let install = installFlag ?? true;
+    if (installFlag === undefined && interactive) {
+        install = unwrap(await dist_confirm({
+            message: `Install dependencies with ${pm.name}?`,
+            initialValue: true
+        }));
+    }
+    let git = gitFlag ?? !isInsideRepo(process.cwd());
+    if (gitFlag === undefined && interactive) {
+        const nested = isInsideRepo(process.cwd());
+        git = unwrap(await dist_confirm({
+            message: nested ? 'Initialize a git repository? (this is already inside one)' : 'Initialize a git repository?',
+            initialValue: !nested
+        }));
+    }
+    const answers = {
+        packageName,
+        targetDir,
+        deploy,
+        styling,
+        formatter,
+        linter,
+        packageManager: pm.name,
+        install,
+        git
+    };
+    // ── Plan, then write ────────────────────────────────────────────────────────────────────────────
+    const plan = plan_plan(answers, pm);
+    if (values['dry-run']) {
+        note([
+            ...plan.files.keys()
+        ].join('\n'), `${plan.files.size} files — ${summary(answers)}`);
+        outro('Dry run: nothing was written.');
+        return;
+    }
+    writePlan(plan, targetDir);
+    log.success(`Created ${plan.files.size} files in ${external_node_path_relative(process.cwd(), targetDir) || '.'}  ·  ${summary(answers)}`);
+    let installed = false;
+    if (install) {
+        log.step(`Installing dependencies with ${pm.name}…`);
+        installed = runInstall(pm, targetDir);
+        if (!installed) log.warn(`${pm.name} install failed — run it yourself and the rest will work.`);
+    }
+    /*
+   * Format the scaffold with the tool it was scaffolded with, so a fresh project passes its own
+   * `format:check` instead of reporting a diff nobody made. Needs the install, since the formatter is a
+   * devDependency — hence the skip, rather than a failure, when there is none.
+   */ if (installed && formatter !== 'none') {
+        if (!runScript(pm, 'format', targetDir)) log.warn(`\`${pm.run} format\` failed — the files are fine, the formatter is not.`);
+    }
+    if (git) {
+        if (!hasGit(targetDir)) {
+            log.warn('git was not found on PATH — skipped.');
+        } else {
+            const result = initRepo(targetDir);
+            if (result === 'initialized') log.warn('Repository initialized, but the first commit failed — set git user.name and user.email.');
+            if (result === 'failed') log.warn('git init failed — skipped.');
+        }
+    }
+    note(nextSteps(answers, plan, pm, {
+        directory,
+        installed
+    }), 'Next');
+    outro('Happy building.');
+}
+main().catch((error)=>{
+    log.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});
+
+})();
+