@oakoliver/gum 1.0.1

package/dist/cjs/index.cjs

@@ -0,0 +1,2161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  exactMatches: () => exactMatches,
+  extractStyleOptions: () => extractStyleOptions,
+  flagBool: () => flagBool,
+  flagInt: () => flagInt,
+  flagStr: () => flagStr,
+  flagWithEnv: () => flagWithEnv,
+  fuzzyFind: () => fuzzyFind,
+  fuzzyFindNoSort: () => fuzzyFindNoSort,
+  isStdinEmpty: () => isStdinEmpty,
+  listFiles: () => listFiles,
+  matchAll: () => matchAll,
+  matchedRanges: () => matchedRanges,
+  parseArgs: () => parseArgs,
+  parsePadding: () => parsePadding,
+  readStdin: () => readStdin,
+  runChoose: () => run,
+  runConfirm: () => run2,
+  runFile: () => run3,
+  runFormat: () => run4,
+  runInput: () => run5,
+  runJoin: () => run6,
+  runLog: () => run7,
+  runPager: () => run8,
+  runSpin: () => run9,
+  runStyle: () => run10,
+  runTable: () => run11,
+  runWrite: () => run12,
+  stripAnsi: () => stripAnsi,
+  toLipgloss: () => toLipgloss
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/fuzzy.ts
+function fuzzyFind(pattern, choices) {
+  if (!pattern) return matchAll(choices);
+  const matches = [];
+  const lowerPattern = pattern.toLowerCase();
+  for (let i = 0; i < choices.length; i++) {
+    const choice = choices[i];
+    const result = fuzzyMatch(lowerPattern, choice);
+    if (result) {
+      matches.push({
+        str: choice,
+        index: i,
+        matchedIndexes: result.indexes,
+        score: result.score
+      });
+    }
+  }
+  matches.sort((a, b) => b.score - a.score);
+  return matches;
+}
+function fuzzyFindNoSort(pattern, choices) {
+  if (!pattern) return matchAll(choices);
+  const matches = [];
+  const lowerPattern = pattern.toLowerCase();
+  for (let i = 0; i < choices.length; i++) {
+    const choice = choices[i];
+    const result = fuzzyMatch(lowerPattern, choice);
+    if (result) {
+      matches.push({
+        str: choice,
+        index: i,
+        matchedIndexes: result.indexes,
+        score: result.score
+      });
+    }
+  }
+  return matches;
+}
+function matchAll(choices) {
+  return choices.map((str, index) => ({
+    str,
+    index,
+    matchedIndexes: [],
+    score: 0
+  }));
+}
+function exactMatches(search, choices) {
+  if (!search) return matchAll(choices);
+  const lowerSearch = search.toLowerCase();
+  const matches = [];
+  for (let i = 0; i < choices.length; i++) {
+    const choice = choices[i];
+    const lowerChoice = choice.toLowerCase();
+    const index = lowerChoice.indexOf(lowerSearch);
+    if (index >= 0) {
+      const matchedIndexes = [];
+      for (let s = 0; s < lowerSearch.length; s++) {
+        matchedIndexes.push(index + s);
+      }
+      matches.push({
+        str: choice,
+        index: i,
+        matchedIndexes,
+        score: 0
+      });
+    }
+  }
+  return matches;
+}
+function fuzzyMatch(lowerPattern, str) {
+  const lowerStr = str.toLowerCase();
+  const indexes = [];
+  let score = 0;
+  let patternIdx = 0;
+  let prevMatchIdx = -1;
+  for (let i = 0; i < lowerStr.length && patternIdx < lowerPattern.length; i++) {
+    if (lowerStr[i] === lowerPattern[patternIdx]) {
+      indexes.push(i);
+      if (prevMatchIdx !== -1 && i === prevMatchIdx + 1) {
+        score += 4;
+      }
+      if (i === 0 || str[i - 1] === " " || str[i - 1] === "/" || str[i - 1] === "." || str[i - 1] === "-" || str[i - 1] === "_") {
+        score += 2;
+      }
+      if (str[i] === lowerPattern[patternIdx]) {
+        score += 1;
+      }
+      prevMatchIdx = i;
+      patternIdx++;
+    }
+  }
+  if (patternIdx !== lowerPattern.length) return null;
+  return { indexes, score };
+}
+function matchedRanges(indexes) {
+  if (indexes.length === 0) return [];
+  let current = [indexes[0], indexes[0]];
+  if (indexes.length === 1) return [current];
+  const out = [];
+  for (let i = 1; i < indexes.length; i++) {
+    if (indexes[i] === current[1] + 1) {
+      current[1] = indexes[i];
+    } else {
+      out.push(current);
+      current = [indexes[i], indexes[i]];
+    }
+  }
+  out.push(current);
+  return out;
+}
+
+// src/style.ts
+var import_lipgloss = require("@oakoliver/lipgloss");
+
+// src/internal/decode.ts
+var alignMap = {
+  center: 0.5,
+  left: 0,
+  top: 0,
+  bottom: 1,
+  right: 1,
+  middle: 0.5
+};
+var borderMap = {
+  double: "double",
+  hidden: "hidden",
+  none: "none",
+  normal: "normal",
+  rounded: "rounded",
+  thick: "thick"
+};
+
+// src/style.ts
+function parsePadding(s) {
+  if (!s) return [0, 0, 0, 0];
+  const tokens = s.trim().split(/\s+/);
+  if (tokens.length > 4) return [0, 0, 0, 0];
+  const ints = [];
+  for (const token of tokens) {
+    const n = parseInt(token, 10);
+    if (isNaN(n)) return [0, 0, 0, 0];
+    ints.push(n);
+  }
+  if (ints.length === 1) return [ints[0], ints[0], ints[0], ints[0]];
+  if (ints.length === 2) return [ints[0], ints[1], ints[0], ints[1]];
+  if (ints.length === 4) return [ints[0], ints[1], ints[2], ints[3]];
+  return [0, 0, 0, 0];
+}
+function toLipgloss(opts) {
+  let s = (0, import_lipgloss.newStyle)();
+  if (opts.foreground) s = s.foreground(opts.foreground);
+  if (opts.background) s = s.background(opts.background);
+  if (opts.borderForeground) s = s.borderForeground(opts.borderForeground);
+  if (opts.borderBackground) s = s.borderBackground(opts.borderBackground);
+  if (opts.align && alignMap[opts.align] !== void 0) {
+    s = s.align(alignMap[opts.align]);
+  }
+  if (opts.border && borderMap[opts.border]) {
+    s = s.border(opts.border);
+  }
+  if (opts.height !== void 0 && opts.height > 0) s = s.height(opts.height);
+  if (opts.width !== void 0 && opts.width > 0) s = s.width(opts.width);
+  if (opts.margin) {
+    const [t, r, b, l] = parsePadding(opts.margin);
+    s = s.marginTop(t).marginRight(r).marginBottom(b).marginLeft(l);
+  }
+  if (opts.padding) {
+    const [t, r, b, l] = parsePadding(opts.padding);
+    s = s.paddingTop(t).paddingRight(r).paddingBottom(b).paddingLeft(l);
+  }
+  if (opts.bold) s = s.bold(true);
+  if (opts.faint) s = s.faint(true);
+  if (opts.italic) s = s.italic(true);
+  if (opts.strikethrough) s = s.strikethrough(true);
+  if (opts.underline) s = s.underline(true);
+  return s;
+}
+function extractStyleOptions(flags, prefix) {
+  const get = (key) => flags[`${prefix}.${key}`] ?? flags[`${prefix}-${key}`];
+  return {
+    foreground: get("foreground"),
+    background: get("background"),
+    border: get("border"),
+    borderBackground: get("border-background") ?? get("borderBackground"),
+    borderForeground: get("border-foreground") ?? get("borderForeground"),
+    align: get("align"),
+    height: get("height") !== void 0 ? parseInt(get("height"), 10) : void 0,
+    width: get("width") !== void 0 ? parseInt(get("width"), 10) : void 0,
+    margin: get("margin"),
+    padding: get("padding"),
+    bold: get("bold") === true || get("bold") === "true",
+    faint: get("faint") === true || get("faint") === "true",
+    italic: get("italic") === true || get("italic") === "true",
+    strikethrough: get("strikethrough") === true || get("strikethrough") === "true",
+    underline: get("underline") === true || get("underline") === "true"
+  };
+}
+
+// src/parser.ts
+var BOOL_FLAGS = /* @__PURE__ */ new Set([
+  "no-limit",
+  "no-show-help",
+  "no-strip-ansi",
+  "ordered",
+  "reverse",
+  "no-strict",
+  "strict",
+  "select-if-one",
+  "sort",
+  "no-sort",
+  "affirmative",
+  "negative",
+  "default",
+  "bold",
+  "faint",
+  "italic",
+  "strikethrough",
+  "underline",
+  "horizontal",
+  "vertical",
+  "show-line-numbers",
+  "soft-wrap",
+  "show-help",
+  "strip-ansi",
+  "cursor.bold",
+  "cursor.faint",
+  "cursor.italic",
+  "cursor.strikethrough",
+  "cursor.underline",
+  "header.bold",
+  "header.faint",
+  "header.italic",
+  "header.strikethrough",
+  "header.underline",
+  "selected.bold",
+  "selected.faint",
+  "selected.italic",
+  "selected.strikethrough",
+  "selected.underline",
+  "unselected.bold",
+  "unselected.faint",
+  "unselected.italic",
+  "unselected.strikethrough",
+  "unselected.underline",
+  "text.bold",
+  "text.faint",
+  "text.italic",
+  "text.strikethrough",
+  "text.underline",
+  "match.bold",
+  "match.faint",
+  "match.italic",
+  "match.strikethrough",
+  "match.underline",
+  "indicator.bold",
+  "indicator.faint",
+  "indicator.italic",
+  "indicator.strikethrough",
+  "indicator.underline",
+  "prompt.bold",
+  "prompt.faint",
+  "prompt.italic",
+  "prompt.strikethrough",
+  "prompt.underline",
+  "item.bold",
+  "item.faint",
+  "item.italic",
+  "item.strikethrough",
+  "item.underline",
+  "fuzzy",
+  "exact"
+]);
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    return { command: "", flags: {}, args: [] };
+  }
+  const command = argv[0];
+  if (command === "--help" || command === "-h") {
+    return { command: "help", flags: {}, args: [] };
+  }
+  if (command === "--version" || command === "-v") {
+    return { command: "version", flags: {}, args: [] };
+  }
+  const flags = {};
+  const args = [];
+  let i = 1;
+  let pastFlags = false;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (pastFlags) {
+      args.push(arg);
+      i++;
+      continue;
+    }
+    if (arg === "--") {
+      pastFlags = true;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const eqIndex = arg.indexOf("=");
+      if (eqIndex !== -1) {
+        const key = arg.substring(2, eqIndex);
+        const value = arg.substring(eqIndex + 1);
+        flags[key] = value;
+        i++;
+      } else {
+        const key = arg.substring(2);
+        if (key.startsWith("no-") && !BOOL_FLAGS.has(key)) {
+          const positiveKey = key.substring(3);
+          flags[positiveKey] = false;
+          i++;
+          continue;
+        }
+        if (isBoolFlag(key)) {
+          flags[key] = true;
+          i++;
+        } else if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+          flags[key] = argv[i + 1];
+          i += 2;
+        } else {
+          flags[key] = true;
+          i++;
+        }
+      }
+    } else {
+      args.push(arg);
+      i++;
+    }
+  }
+  return { command, flags, args };
+}
+function isBoolFlag(key) {
+  if (BOOL_FLAGS.has(key)) return true;
+  const parts = key.split(".");
+  if (parts.length === 2) {
+    const suffix = parts[1];
+    if (["bold", "faint", "italic", "strikethrough", "underline"].includes(suffix)) {
+      return true;
+    }
+  }
+  return false;
+}
+function flagStr(flags, key, defaultValue) {
+  const v = flags[key];
+  if (v === void 0) return defaultValue;
+  if (typeof v === "boolean") return String(v);
+  return v;
+}
+function flagInt(flags, key, defaultValue) {
+  const v = flags[key];
+  if (v === void 0) return defaultValue;
+  const n = parseInt(String(v), 10);
+  return isNaN(n) ? defaultValue : n;
+}
+function flagBool(flags, key, defaultValue = false) {
+  const v = flags[key];
+  if (v === void 0) return defaultValue;
+  if (typeof v === "boolean") return v;
+  return v === "true" || v === "1" || v === "yes";
+}
+function flagWithEnv(flags, key, envKey, defaultValue) {
+  const v = flags[key];
+  if (v !== void 0) return typeof v === "boolean" ? String(v) : v;
+  const envVal = process.env[envKey];
+  if (envVal !== void 0) return envVal;
+  return defaultValue;
+}
+
+// src/commands/choose.ts
+var import_bubbletea = require("@oakoliver/bubbletea");
+var import_bubbles = require("@oakoliver/bubbles");
+
+// src/internal/stdin.ts
+var fs = __toESM(require("node:fs"), 1);
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function isStdinEmpty() {
+  try {
+    const stat = fs.fstatSync(0);
+    if (stat.isFIFO()) return false;
+    if (stat.size > 0) return false;
+    return true;
+  } catch {
+    return true;
+  }
+}
+function readStdin(opts = {}) {
+  if (isStdinEmpty()) {
+    throw new Error("stdin is empty");
+  }
+  const chunks = [];
+  const buf = Buffer.alloc(1024);
+  let bytesRead;
+  try {
+    while (true) {
+      bytesRead = fs.readSync(0, buf, 0, buf.length, null);
+      if (bytesRead === 0) break;
+      chunks.push(Buffer.from(buf.subarray(0, bytesRead)));
+      if (opts.singleLine) {
+        const combined = Buffer.concat(chunks).toString("utf-8");
+        const nlIndex = combined.indexOf("\n");
+        if (nlIndex !== -1) {
+          const line = combined.substring(0, nlIndex).trim();
+          return opts.stripAnsi ? stripAnsi(line) : line;
+        }
+      }
+    }
+  } catch {
+  }
+  let result = Buffer.concat(chunks).toString("utf-8").trim();
+  if (opts.singleLine) {
+    const nlIndex = result.indexOf("\n");
+    if (nlIndex !== -1) {
+      result = result.substring(0, nlIndex).trim();
+    }
+  }
+  if (opts.stripAnsi) {
+    result = stripAnsi(result);
+  }
+  return result;
+}
+
+// src/internal/tty.ts
+var tty = __toESM(require("node:tty"), 1);
+var _isTTY;
+function isTTY() {
+  if (_isTTY === void 0) {
+    _isTTY = tty.isatty(1);
+  }
+  return _isTTY;
+}
+function println(s) {
+  if (isTTY()) {
+    console.log(s);
+  } else {
+    console.log(stripAnsi(s));
+  }
+}
+
+// src/internal/exit.ts
+var STATUS_ABORTED = 130;
+
+// src/commands/choose.ts
+function createModel(parsed) {
+  const flags = parsed.flags;
+  let items = [];
+  if (parsed.args.length > 0) {
+    items = parsed.args;
+  } else if (!isStdinEmpty()) {
+    const stdinContent = readStdin();
+    items = stdinContent.split("\n").filter((line) => line.length > 0);
+  }
+  if (items.length === 0) {
+    console.error("Error: no items provided");
+    process.exit(1);
+  }
+  const limit = flagInt(flags, "limit", 1);
+  const noLimit = flagBool(flags, "no-limit", false);
+  const height = flagInt(flags, "height", 10);
+  const header = flagStr(flags, "header", "");
+  const cursorPrefix = flagStr(flags, "cursor", "> ");
+  const selectedPrefix = flagStr(flags, "selected.prefix", "[\u2713] ");
+  const unselectedPrefix = flagStr(flags, "unselected.prefix", "[ ] ");
+  const selectIfOne = flagBool(flags, "select-if-one", false);
+  const ordered = flagBool(flags, "ordered", false);
+  const selectedItems = flagStr(flags, "selected", "").split(",").filter(Boolean);
+  const cursorStyle = toLipgloss(extractStyleOptions(flags, "cursor"));
+  const itemStyle = toLipgloss(extractStyleOptions(flags, "item"));
+  const selectedItemStyle = toLipgloss(extractStyleOptions(flags, "selected"));
+  const headerStyle = toLipgloss(extractStyleOptions(flags, "header"));
+  const choiceItems = items.map((text) => ({
+    text,
+    selected: selectedItems.includes(text),
+    order: 0
+  }));
+  const numSelected = choiceItems.filter((i) => i.selected).length;
+  const paginator = (0, import_bubbles.newPaginator)();
+  paginator.type = import_bubbles.PaginatorType.Dots;
+  paginator.perPage = height;
+  paginator.setTotalPages(choiceItems.length);
+  if (selectIfOne && choiceItems.length === 1) {
+    choiceItems[0].selected = true;
+  }
+  const isMulti = noLimit || limit > 1;
+  return {
+    items: choiceItems,
+    cursor: 0,
+    paginator,
+    limit: noLimit ? 0 : limit,
+    noLimit,
+    numSelected,
+    aborted: false,
+    quitting: false,
+    header,
+    cursorPrefix,
+    selectedPrefix: isMulti ? selectedPrefix : cursorPrefix,
+    unselectedPrefix: isMulti ? unselectedPrefix : "  ",
+    cursorStyle,
+    itemStyle,
+    selectedItemStyle,
+    headerStyle,
+    height,
+    selectIfOne,
+    init() {
+      return null;
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea.WindowSizeMsg) {
+        this.paginator.perPage = msg.height - 1;
+        if (this.header) this.paginator.perPage--;
+        this.paginator.setTotalPages(this.items.length);
+        return [this, null];
+      }
+      if (msg instanceof import_bubbletea.KeyPressMsg) {
+        if (msg.mod & import_bubbletea.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea.Quit)()];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Escape) {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea.Quit)()];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Enter) {
+          this.quitting = true;
+          if (!this.noLimit && this.limit === 1 && this.numSelected === 0) {
+            this.items[this.cursor].selected = true;
+          }
+          return [this, () => (0, import_bubbletea.Quit)()];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Down || msg.text === "j" || msg.mod & import_bubbletea.KeyMod.Ctrl && msg.text === "n") {
+          this.cursor = Math.min(this.cursor + 1, this.items.length - 1);
+          const [start, end] = this.paginator.getSliceBounds(this.items.length);
+          if (this.cursor >= end) this.paginator.nextPage();
+          return [this, null];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Up || msg.text === "k" || msg.mod & import_bubbletea.KeyMod.Ctrl && msg.text === "p") {
+          this.cursor = Math.max(this.cursor - 1, 0);
+          const [start] = this.paginator.getSliceBounds(this.items.length);
+          if (this.cursor < start) this.paginator.prevPage();
+          return [this, null];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Home || msg.text === "g") {
+          this.cursor = 0;
+          this.paginator.page = 0;
+          return [this, null];
+        }
+        if (msg.code === import_bubbletea.KeyCode.End || msg.text === "G") {
+          this.cursor = this.items.length - 1;
+          this.paginator.page = this.paginator.totalPages - 1;
+          return [this, null];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Right || msg.text === "l") {
+          this.paginator.nextPage();
+          const [start] = this.paginator.getSliceBounds(this.items.length);
+          this.cursor = start;
+          return [this, null];
+        }
+        if (msg.code === import_bubbletea.KeyCode.Left || msg.text === "h") {
+          this.paginator.prevPage();
+          const [start] = this.paginator.getSliceBounds(this.items.length);
+          this.cursor = start;
+          return [this, null];
+        }
+        if ((this.noLimit || this.limit > 1) && (msg.code === import_bubbletea.KeyCode.Space || msg.code === import_bubbletea.KeyCode.Tab || msg.text === "x")) {
+          const item = this.items[this.cursor];
+          if (item.selected) {
+            item.selected = false;
+            this.numSelected--;
+          } else if (this.noLimit || this.numSelected < this.limit) {
+            item.selected = true;
+            this.numSelected++;
+            item.order = this.numSelected;
+          }
+          return [this, null];
+        }
+        if ((this.noLimit || this.limit > 1) && msg.mod & import_bubbletea.KeyMod.Ctrl && msg.text === "a") {
+          const allSelected = this.items.every((i) => i.selected);
+          for (const item of this.items) {
+            item.selected = !allSelected;
+          }
+          this.numSelected = allSelected ? 0 : this.items.length;
+          return [this, null];
+        }
+      }
+      return [this, null];
+    },
+    view() {
+      if (this.quitting) return "";
+      const [start, end] = this.paginator.getSliceBounds(this.items.length);
+      const visible = this.items.slice(start, end);
+      let out = "";
+      if (this.header) {
+        out += this.headerStyle.render(this.header) + "\n";
+      }
+      const isMulti2 = this.noLimit || this.limit > 1;
+      for (let i = 0; i < visible.length; i++) {
+        const idx = start + i;
+        const item = visible[i];
+        const isCursor = idx === this.cursor;
+        let prefix;
+        let style;
+        if (isCursor) {
+          prefix = isMulti2 ? item.selected ? this.selectedPrefix : this.unselectedPrefix : this.cursorPrefix;
+          style = this.cursorStyle;
+        } else if (item.selected) {
+          prefix = this.selectedPrefix;
+          style = this.selectedItemStyle;
+        } else {
+          prefix = isMulti2 ? this.unselectedPrefix : "  ";
+          style = this.itemStyle;
+        }
+        out += style.render(prefix + item.text);
+        if (i < visible.length - 1) out += "\n";
+      }
+      if (this.paginator.totalPages > 1) {
+        out += "\n" + this.paginator.view();
+      }
+      return out;
+    }
+  };
+}
+async function run(parsed) {
+  const model = createModel(parsed);
+  if (model.selectIfOne && model.items.length === 1) {
+    println(model.items[0].text);
+    return;
+  }
+  const p = new import_bubbletea.Program(model);
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+  const selected = final.items.filter((i) => i.selected);
+  if (selected.length === 0) return;
+  for (const item of selected) {
+    println(item.text);
+  }
+}
+
+// src/commands/confirm.ts
+var import_bubbletea2 = require("@oakoliver/bubbletea");
+
+// src/internal/timeout.ts
+function parseDuration(s) {
+  if (!s || s === "0" || s === "0s" || s === "0ms") return 0;
+  const match = s.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (!match) return 0;
+  const value = parseFloat(match[1]);
+  const unit = match[2] || "ms";
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    default:
+      return 0;
+  }
+}
+
+// src/commands/confirm.ts
+function createModel2(parsed) {
+  const flags = parsed.flags;
+  const prompt = parsed.args.length > 0 ? parsed.args.join(" ") : flagStr(flags, "prompt", "Are you sure?");
+  const affirmative = flagStr(flags, "affirmative", "Yes");
+  const negative = flagStr(flags, "negative", "No");
+  const defaultValue = flagBool(flags, "default", true);
+  const selectedStyle = toLipgloss(extractStyleOptions(flags, "selected"));
+  const unselectedStyle = toLipgloss(extractStyleOptions(flags, "unselected"));
+  const promptStyle = toLipgloss(extractStyleOptions(flags, "prompt"));
+  return {
+    affirmative,
+    negative,
+    confirmation: defaultValue,
+    defaultValue,
+    quitting: false,
+    aborted: false,
+    hasTimeout: false,
+    prompt,
+    selectedStyle: selectedStyle.padding(0, 3),
+    unselectedStyle: unselectedStyle.padding(0, 3),
+    promptStyle,
+    init() {
+      return null;
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea2.KeyPressMsg) {
+        if (msg.mod & import_bubbletea2.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea2.Quit)()];
+        }
+        if (msg.code === import_bubbletea2.KeyCode.Escape) {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea2.Quit)()];
+        }
+        if (msg.code === import_bubbletea2.KeyCode.Enter) {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea2.Quit)()];
+        }
+        if (msg.code === import_bubbletea2.KeyCode.Left || msg.code === import_bubbletea2.KeyCode.Right || msg.text === "h" || msg.text === "l" || msg.code === import_bubbletea2.KeyCode.Tab) {
+          this.confirmation = !this.confirmation;
+          return [this, null];
+        }
+        if (msg.text === "y" || msg.text === "Y") {
+          this.confirmation = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea2.Quit)()];
+        }
+        if (msg.text === "n" || msg.text === "N") {
+          this.confirmation = false;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea2.Quit)()];
+        }
+      }
+      return [this, null];
+    },
+    view() {
+      if (this.quitting) return "";
+      let out = "";
+      out += this.promptStyle.render(this.prompt) + "\n\n";
+      if (this.confirmation) {
+        out += this.selectedStyle.render(this.affirmative) + " ";
+        out += this.unselectedStyle.render(this.negative);
+      } else {
+        out += this.unselectedStyle.render(this.affirmative) + " ";
+        out += this.selectedStyle.render(this.negative);
+      }
+      return out;
+    }
+  };
+}
+async function run2(parsed) {
+  const model = createModel2(parsed);
+  const timeoutStr = flagStr(parsed.flags, "timeout", "0");
+  const timeoutMs = parseDuration(timeoutStr);
+  const p = new import_bubbletea2.Program(model);
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+  process.exit(final.confirmation ? 0 : 1);
+}
+
+// src/commands/file.ts
+var import_bubbletea3 = require("@oakoliver/bubbletea");
+var import_bubbles2 = require("@oakoliver/bubbles");
+var import_lipgloss2 = require("@oakoliver/lipgloss");
+var import_node_path = require("node:path");
+function helpView() {
+  return "  \u2193\u2191 navigate \u2022 esc close \u2022 enter select";
+}
+function createModel3(parsed) {
+  const flags = parsed.flags;
+  const startPath = (0, import_node_path.resolve)(parsed.args[0] ?? flagStr(flags, "path", "."));
+  const cursor = flagStr(flags, "cursor", ">");
+  const showHidden = flagBool(flags, "all", false);
+  const showPermissions = flagBool(flags, "permissions", true);
+  const showSize = flagBool(flags, "size", true);
+  const fileAllowed = flagBool(flags, "file", true);
+  const dirAllowed = flagBool(flags, "directory", false);
+  const showHelp = flagBool(flags, "show-help", true);
+  const header = flagStr(flags, "header", "");
+  const height = flagInt(flags, "height", 10);
+  const paddingStr = flagStr(flags, "padding", "0 0");
+  const padding = parsePadding(paddingStr);
+  if (!fileAllowed && !dirAllowed) {
+    console.error("Error: at least one of --file or --directory must be enabled");
+    process.exit(1);
+  }
+  const fp = (0, import_bubbles2.newFilePicker)();
+  fp.currentDirectory = startPath;
+  fp.cursor = cursor;
+  fp.showHidden = showHidden;
+  fp.showPermissions = showPermissions;
+  fp.showSize = showSize;
+  fp.fileAllowed = fileAllowed;
+  fp.dirAllowed = dirAllowed;
+  if (height > 0) {
+    fp.autoHeight = false;
+    fp.setHeight(height);
+  } else {
+    fp.autoHeight = true;
+  }
+  const cursorOpts = extractStyleOptions(flags, "cursor");
+  if (!cursorOpts.foreground) cursorOpts.foreground = "212";
+  fp.styles.cursor = toLipgloss(cursorOpts);
+  const symlinkOpts = extractStyleOptions(flags, "symlink");
+  if (!symlinkOpts.foreground) symlinkOpts.foreground = "36";
+  fp.styles.symlink = toLipgloss(symlinkOpts);
+  const directoryOpts = extractStyleOptions(flags, "directory");
+  if (!directoryOpts.foreground) directoryOpts.foreground = "99";
+  fp.styles.directory = toLipgloss(directoryOpts);
+  const fileOpts = extractStyleOptions(flags, "file");
+  fp.styles.file = toLipgloss(fileOpts);
+  const permOpts = extractStyleOptions(flags, "permissions");
+  if (!permOpts.foreground) permOpts.foreground = "244";
+  fp.styles.permission = toLipgloss(permOpts);
+  const selectedOpts = extractStyleOptions(flags, "selected");
+  if (!selectedOpts.foreground) selectedOpts.foreground = "212";
+  if (!selectedOpts.bold) selectedOpts.bold = true;
+  fp.styles.selected = toLipgloss(selectedOpts);
+  const fileSizeOpts = extractStyleOptions(flags, "file-size");
+  if (!fileSizeOpts.foreground) fileSizeOpts.foreground = "240";
+  fp.styles.fileSize = toLipgloss(fileSizeOpts);
+  const headerStyle = toLipgloss((() => {
+    const opts = extractStyleOptions(flags, "header");
+    if (!opts.foreground) opts.foreground = "99";
+    return opts;
+  })());
+  return {
+    filepicker: fp,
+    header,
+    headerStyle,
+    selectedPath: "",
+    quitting: false,
+    showHelp,
+    padding,
+    init() {
+      return this.filepicker.init();
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea3.WindowSizeMsg) {
+        const usable = msg.height - this.padding[0] - this.padding[2];
+        this.filepicker.setHeight(Math.max(usable, 1));
+        return [this, null];
+      }
+      if (msg instanceof import_bubbletea3.KeyPressMsg) {
+        if (msg.mod & import_bubbletea3.KeyMod.Ctrl && msg.text === "c") {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea3.Quit)()];
+        }
+        if (msg.code === import_bubbletea3.KeyCode.Escape || msg.text === "q") {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea3.Quit)()];
+        }
+      }
+      const [updatedFp, cmd] = this.filepicker.update(msg);
+      this.filepicker = updatedFp;
+      const result = this.filepicker.didSelectFile(msg);
+      const didSelect = Array.isArray(result) ? result[0] : result?.selected;
+      const selectedPath = Array.isArray(result) ? result[1] : result?.path;
+      if (didSelect && selectedPath) {
+        this.selectedPath = selectedPath;
+        this.quitting = true;
+        return [this, () => (0, import_bubbletea3.Quit)()];
+      }
+      return [this, cmd];
+    },
+    view() {
+      if (this.quitting) return "";
+      const parts = [];
+      if (this.header) {
+        parts.push(this.headerStyle.render(this.header));
+      }
+      parts.push(this.filepicker.view());
+      if (this.showHelp) {
+        parts.push(helpView());
+      }
+      let content = (0, import_lipgloss2.joinVertical)(import_lipgloss2.Left, ...parts);
+      const [pt, pr, pb, pl] = this.padding;
+      if (pt || pr || pb || pl) {
+        const padStyle = (0, import_lipgloss2.newStyle)().paddingTop(pt).paddingRight(pr).paddingBottom(pb).paddingLeft(pl);
+        content = padStyle.render(content);
+      }
+      return content;
+    }
+  };
+}
+async function run3(parsed) {
+  const model = createModel3(parsed);
+  const p = new import_bubbletea3.Program(model);
+  const final = await p.run();
+  if (final.quitting && !final.selectedPath) {
+    process.exit(STATUS_ABORTED);
+  }
+  if (final.selectedPath) {
+    console.log(final.selectedPath);
+  } else {
+    console.error("Error: no file selected");
+    process.exit(1);
+  }
+}
+
+// src/commands/format.ts
+var import_glamour = require("@oakoliver/glamour");
+function detectFormatType(flags) {
+  if (flagBool(flags, "type", false)) {
+    const t = flagStr(flags, "type", "markdown");
+    if (["markdown", "code", "emoji", "template"].includes(t)) {
+      return t;
+    }
+  }
+  if (flags["code"] === true) return "code";
+  if (flags["emoji"] === true) return "emoji";
+  if (flags["template"] === true) return "template";
+  if (flags["markdown"] === true) return "markdown";
+  return "markdown";
+}
+function formatCode(text, language) {
+  const wrapped = "```" + language + "\n" + text + "\n```";
+  return (0, import_glamour.render)(wrapped, "dark");
+}
+function formatEmoji(text) {
+  return text.replace(/:([a-z0-9_+-]+):/g, (match, name) => {
+    const emoji = EMOJI_MAP[name];
+    return emoji || match;
+  });
+}
+function formatTemplate(text, _flags) {
+  return text.replace(/\{\{\s*\.Env\.(\w+)\s*\}\}/g, (_match, key) => {
+    return process.env[key] || "";
+  });
+}
+var EMOJI_MAP = {
+  "smile": "\u{1F604}",
+  "laughing": "\u{1F606}",
+  "blush": "\u{1F60A}",
+  "smiley": "\u{1F603}",
+  "relaxed": "\u263A\uFE0F",
+  "heart_eyes": "\u{1F60D}",
+  "kissing_heart": "\u{1F618}",
+  "wink": "\u{1F609}",
+  "stuck_out_tongue_winking_eye": "\u{1F61C}",
+  "sunglasses": "\u{1F60E}",
+  "thumbsup": "\u{1F44D}",
+  "thumbsdown": "\u{1F44E}",
+  "clap": "\u{1F44F}",
+  "wave": "\u{1F44B}",
+  "fire": "\u{1F525}",
+  "heart": "\u2764\uFE0F",
+  "star": "\u2B50",
+  "sparkles": "\u2728",
+  "check": "\u2705",
+  "x": "\u274C",
+  "warning": "\u26A0\uFE0F",
+  "bulb": "\u{1F4A1}",
+  "rocket": "\u{1F680}",
+  "tada": "\u{1F389}",
+  "party_popper": "\u{1F389}",
+  "coffee": "\u2615",
+  "beer": "\u{1F37A}",
+  "pizza": "\u{1F355}",
+  "bug": "\u{1F41B}",
+  "wrench": "\u{1F527}",
+  "hammer": "\u{1F528}",
+  "gear": "\u2699\uFE0F",
+  "lock": "\u{1F512}",
+  "key": "\u{1F511}",
+  "link": "\u{1F517}",
+  "package": "\u{1F4E6}",
+  "memo": "\u{1F4DD}",
+  "book": "\u{1F4D6}",
+  "pencil": "\u270F\uFE0F",
+  "scissors": "\u2702\uFE0F",
+  "computer": "\u{1F4BB}",
+  "phone": "\u{1F4F1}",
+  "email": "\u{1F4E7}",
+  "globe": "\u{1F30D}",
+  "sun": "\u2600\uFE0F",
+  "moon": "\u{1F319}",
+  "cloud": "\u2601\uFE0F",
+  "rainbow": "\u{1F308}",
+  "zap": "\u26A1",
+  "boom": "\u{1F4A5}",
+  "collision": "\u{1F4A5}",
+  "eyes": "\u{1F440}",
+  "brain": "\u{1F9E0}",
+  "muscle": "\u{1F4AA}",
+  "green_circle": "\u{1F7E2}",
+  "red_circle": "\u{1F534}",
+  "blue_circle": "\u{1F535}",
+  "white_check_mark": "\u2705",
+  "heavy_check_mark": "\u2714\uFE0F",
+  "arrow_right": "\u27A1\uFE0F",
+  "arrow_left": "\u2B05\uFE0F",
+  "arrow_up": "\u2B06\uFE0F",
+  "arrow_down": "\u2B07\uFE0F",
+  "plus": "\u2795",
+  "minus": "\u2796"
+};
+async function run4(parsed) {
+  const flags = parsed.flags;
+  const formatType = detectFormatType(flags);
+  const language = flagStr(flags, "language", "") || flagStr(flags, "lang", "");
+  const theme = flagStr(flags, "theme", "dark");
+  let text;
+  if (parsed.args.length > 0) {
+    text = parsed.args.join("\n");
+  } else if (!isStdinEmpty()) {
+    text = readStdin();
+  } else {
+    text = "";
+  }
+  if (!text) return;
+  let output;
+  switch (formatType) {
+    case "code":
+      output = formatCode(text, language);
+      break;
+    case "emoji":
+      output = formatEmoji(text);
+      break;
+    case "template":
+      output = formatTemplate(text, flags);
+      break;
+    case "markdown":
+    default:
+      output = (0, import_glamour.render)(text, theme);
+      break;
+  }
+  process.stdout.write(output);
+  if (!output.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+}
+
+// src/commands/input.ts
+var import_bubbletea4 = require("@oakoliver/bubbletea");
+var import_bubbles3 = require("@oakoliver/bubbles");
+function createModel4(parsed) {
+  const flags = parsed.flags;
+  const ti = (0, import_bubbles3.newTextInput)();
+  ti.placeholder = flagWithEnv(flags, "placeholder", "GUM_INPUT_PLACEHOLDER", "Type something...");
+  ti.prompt = flagWithEnv(flags, "prompt", "GUM_INPUT_PROMPT", "> ");
+  const value = flagStr(flags, "value", "");
+  if (value) ti.setValue(value);
+  const charLimit = flagInt(flags, "char-limit", 400);
+  ti.charLimit = charLimit;
+  const echoModeStr = flagStr(flags, "echo-mode", "normal");
+  switch (echoModeStr) {
+    case "password":
+      ti.echoMode = import_bubbles3.EchoMode.EchoPassword;
+      break;
+    case "none":
+      ti.echoMode = import_bubbles3.EchoMode.EchoNone;
+      break;
+    default:
+      ti.echoMode = import_bubbles3.EchoMode.EchoNormal;
+      break;
+  }
+  const password = flagBool(flags, "password", false);
+  if (password) ti.echoMode = import_bubbles3.EchoMode.EchoPassword;
+  const widthFlag = flagInt(flags, "width", 0);
+  const autoWidth = widthFlag === 0;
+  if (!autoWidth) {
+    ti.setWidth(widthFlag);
+  }
+  const header = flagStr(flags, "header", "");
+  const headerStyle = toLipgloss(extractStyleOptions(flags, "header"));
+  const promptStyleOpts = extractStyleOptions(flags, "prompt");
+  const promptStyle = toLipgloss(promptStyleOpts);
+  const styles = ti.styles();
+  styles.focused.prompt = promptStyle;
+  ti.setStyles(styles);
+  const cursorStyleOpts = extractStyleOptions(flags, "cursor");
+  const cursorStyle = toLipgloss(cursorStyleOpts);
+  const curStyles = ti.styles();
+  const cursorFg = flagStr(flags, "cursor.foreground", "");
+  if (cursorFg) {
+    curStyles.cursor.color = cursorFg;
+  }
+  ti.setStyles(curStyles);
+  ti.focus();
+  return {
+    textInput: ti,
+    aborted: false,
+    quitting: false,
+    header,
+    headerStyle,
+    autoWidth,
+    width: widthFlag || 80,
+    init() {
+      return null;
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea4.WindowSizeMsg) {
+        this.width = msg.width;
+        if (this.autoWidth) {
+          this.textInput.setWidth(msg.width - 1);
+        }
+        return [this, null];
+      }
+      if (msg instanceof import_bubbletea4.KeyPressMsg) {
+        if (msg.code === import_bubbletea4.KeyCode.Escape || msg.mod & import_bubbletea4.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea4.Quit)()];
+        }
+        if (msg.code === import_bubbletea4.KeyCode.Escape) {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea4.Quit)()];
+        }
+        if (msg.code === import_bubbletea4.KeyCode.Enter) {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea4.Quit)()];
+        }
+      }
+      const [updatedTi, cmd] = this.textInput.update(msg);
+      this.textInput = updatedTi;
+      return [this, cmd];
+    },
+    view() {
+      if (this.quitting) return "";
+      let out = "";
+      if (this.header) {
+        out += this.headerStyle.render(this.header) + "\n";
+      }
+      out += this.textInput.view();
+      return out;
+    }
+  };
+}
+async function run5(parsed) {
+  const model = createModel4(parsed);
+  const p = new import_bubbletea4.Program(model);
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+  process.stdout.write(final.textInput.value() + "\n");
+}
+
+// src/commands/join.ts
+var import_lipgloss3 = require("@oakoliver/lipgloss");
+function parseAlign(s) {
+  switch (s.toLowerCase()) {
+    case "center":
+      return import_lipgloss3.Center;
+    case "right":
+    case "bottom":
+      return import_lipgloss3.Right;
+    case "left":
+    case "top":
+    default:
+      return import_lipgloss3.Left;
+  }
+}
+async function run6(parsed) {
+  const flags = parsed.flags;
+  const horizontal = flagBool(flags, "horizontal", false);
+  const align = flagStr(flags, "align", "left");
+  const texts = parsed.args;
+  if (texts.length === 0) {
+    process.stdout.write("");
+    return;
+  }
+  const pos = parseAlign(align);
+  let result;
+  if (horizontal) {
+    result = (0, import_lipgloss3.joinHorizontal)(pos, ...texts);
+  } else {
+    result = (0, import_lipgloss3.joinVertical)(pos, ...texts);
+  }
+  process.stdout.write(result + "\n");
+}
+
+// src/commands/log.ts
+var import_lipgloss4 = require("@oakoliver/lipgloss");
+var fs2 = __toESM(require("node:fs"), 1);
+var LOG_LEVEL_COLORS = {
+  debug: "#6c757d",
+  info: "#0d6efd",
+  warn: "#ffc107",
+  error: "#dc3545",
+  fatal: "#dc3545",
+  none: ""
+};
+function formatTimestamp(format) {
+  const now = /* @__PURE__ */ new Date();
+  if (format === "TimeOnly" || format === "timeonly") {
+    return now.toLocaleTimeString();
+  }
+  if (format === "DateTime" || format === "datetime") {
+    return now.toLocaleString();
+  }
+  if (format === "DateOnly" || format === "dateonly") {
+    return now.toLocaleDateString();
+  }
+  if (format === "Kitchen" || format === "kitchen") {
+    return now.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+  }
+  if (format === "RFC3339" || format === "rfc3339") {
+    return now.toISOString();
+  }
+  const h = now.getHours().toString().padStart(2, "0");
+  const m = now.getMinutes().toString().padStart(2, "0");
+  const s = now.getSeconds().toString().padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+function formatText(level, message, kvPairs, prefix, timeFormat, levelStyle, keyStyle, valueStyle, separatorStyle, prefixStyle, timeStyle, messageStyle) {
+  const parts = [];
+  if (timeFormat) {
+    parts.push(timeStyle.render(formatTimestamp(timeFormat)));
+  }
+  const levelStr = level.toUpperCase().padEnd(5);
+  parts.push(levelStyle.render(levelStr));
+  if (prefix) {
+    parts.push(prefixStyle.render(prefix));
+  }
+  parts.push(messageStyle.render(message));
+  for (const [key, value] of Object.entries(kvPairs)) {
+    parts.push(
+      keyStyle.render(key) + separatorStyle.render("=") + valueStyle.render(value)
+    );
+  }
+  return parts.join(" ");
+}
+function formatJSON(level, message, kvPairs, prefix, timeFormat) {
+  const obj = {};
+  if (timeFormat) obj["time"] = formatTimestamp(timeFormat);
+  obj["level"] = level.toUpperCase();
+  if (prefix) obj["prefix"] = prefix;
+  obj["msg"] = message;
+  Object.assign(obj, kvPairs);
+  return JSON.stringify(obj);
+}
+function formatLogfmt(level, message, kvPairs, prefix, timeFormat) {
+  const parts = [];
+  if (timeFormat) parts.push(`time=${formatTimestamp(timeFormat)}`);
+  parts.push(`level=${level.toUpperCase()}`);
+  if (prefix) parts.push(`prefix=${prefix}`);
+  parts.push(`msg="${message}"`);
+  for (const [key, value] of Object.entries(kvPairs)) {
+    if (value.includes(" ")) {
+      parts.push(`${key}="${value}"`);
+    } else {
+      parts.push(`${key}=${value}`);
+    }
+  }
+  return parts.join(" ");
+}
+async function run7(parsed) {
+  const flags = parsed.flags;
+  const level = flagStr(flags, "level", "info");
+  const formatter = flagStr(flags, "formatter", "text") || flagStr(flags, "format", "text");
+  const prefix = flagStr(flags, "prefix", "");
+  const timeFormat = flagStr(flags, "time", "");
+  const structured = flagBool(flags, "structured", false);
+  const message = parsed.args.length > 0 ? parsed.args[0] : "";
+  const kvPairs = {};
+  for (let i = 1; i < parsed.args.length; i++) {
+    const arg = parsed.args[i];
+    const eqIdx = arg.indexOf("=");
+    if (eqIdx !== -1) {
+      kvPairs[arg.substring(0, eqIdx)] = arg.substring(eqIdx + 1);
+    }
+  }
+  const levelColor = LOG_LEVEL_COLORS[level] || "";
+  const levelStyle = levelColor ? (0, import_lipgloss4.newStyle)().foreground(levelColor).bold(true) : (0, import_lipgloss4.newStyle)();
+  const keyStyle = toLipgloss(extractStyleOptions(flags, "key"));
+  const valueStyle = toLipgloss(extractStyleOptions(flags, "value"));
+  const separatorStyle = toLipgloss(extractStyleOptions(flags, "separator"));
+  const prefixStyle = toLipgloss(extractStyleOptions(flags, "prefix"));
+  const timeStyle = toLipgloss(extractStyleOptions(flags, "time"));
+  const messageStyle = toLipgloss(extractStyleOptions(flags, "message"));
+  let output;
+  switch (formatter) {
+    case "json":
+      output = formatJSON(level, message, kvPairs, prefix, timeFormat);
+      break;
+    case "logfmt":
+      output = formatLogfmt(level, message, kvPairs, prefix, timeFormat);
+      break;
+    default:
+      output = formatText(
+        level,
+        message,
+        kvPairs,
+        prefix,
+        timeFormat,
+        levelStyle,
+        keyStyle,
+        valueStyle,
+        separatorStyle,
+        prefixStyle,
+        timeStyle,
+        messageStyle
+      );
+      break;
+  }
+  const file = flagStr(flags, "file", "");
+  if (file) {
+    fs2.appendFileSync(file, output + "\n");
+  }
+  process.stderr.write(output + "\n");
+}
+
+// src/commands/pager.ts
+var import_bubbletea5 = require("@oakoliver/bubbletea");
+var import_bubbles4 = require("@oakoliver/bubbles");
+var import_lipgloss5 = require("@oakoliver/lipgloss");
+var HELP_VIEW = "  \u2191/\u2193 navigate \u2022 / search \u2022 n next \u2022 N prev \u2022 q quit";
+function lipglossPadding(style) {
+  const rendered = style.render(" ");
+  const idx = rendered.indexOf(" ");
+  return [idx, rendered.length - 1 - idx];
+}
+function softWrapText(str, maxWidth, wrap) {
+  if (!wrap || maxWidth <= 0) return [str];
+  const lines = [];
+  let remaining = str;
+  while ((0, import_lipgloss5.stringWidth)(remaining) > maxWidth) {
+    let cut = 0;
+    let w = 0;
+    for (let i = 0; i < remaining.length; i++) {
+      const ch = remaining[i];
+      if (ch === "\x1B") {
+        const end = remaining.indexOf("m", i);
+        if (end !== -1) {
+          i = end;
+          continue;
+        }
+      }
+      w++;
+      cut = i + 1;
+      if (w >= maxWidth) break;
+    }
+    if (cut === 0) break;
+    lines.push(remaining.substring(0, cut));
+    remaining = remaining.substring(cut);
+  }
+  if (remaining.length > 0) lines.push(remaining);
+  return lines;
+}
+function processText(model) {
+  const lines = model.origContent.split("\n");
+  const [padL, padR] = lipglossPadding(model.viewportStyle);
+  const lineNumWidth = model.showLineNumbers ? `   ${lines.length} \u2502 `.length : 0;
+  model.maxWidth = model.viewport.width() - padL - padR - lineNumWidth;
+  const processed = [];
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    const prefix = model.showLineNumbers ? model.lineNumberStyle.render(`${String(i + 1).padStart(4)} \u2502 `) : "";
+    if (model.softWrap && model.maxWidth > 0) {
+      const wrapped = softWrapText(line, model.maxWidth, true);
+      for (let j = 0; j < wrapped.length; j++) {
+        processed.push(j === 0 ? prefix + wrapped[j] : " ".repeat(lineNumWidth) + wrapped[j]);
+      }
+    } else {
+      processed.push(prefix + line);
+    }
+  }
+  if (model.showLineNumbers) {
+    const visible = model.viewport.height();
+    while (processed.length < visible) {
+      processed.push(model.lineNumberStyle.render("   ~ \u2502 "));
+    }
+  }
+  model.content = processed.join("\n");
+  model.viewport.setContent(model.content);
+}
+function searchBegin(search) {
+  search.active = true;
+  search.input = (0, import_bubbles4.newTextInput)();
+  search.input.placeholder = "search...";
+  search.input.prompt = "/ ";
+  search.input.focus();
+}
+function searchExecute(model) {
+  const value = model.search.input.value();
+  if (!value) return;
+  let pattern;
+  try {
+    pattern = new RegExp(value, "gi");
+  } catch {
+    return;
+  }
+  const highlighted = model.content.replace(pattern, (m) => model.matchStyle.render(m));
+  model.content = highlighted;
+  model.viewport.setContent(model.content);
+  const styledSample = model.matchStyle.render(value);
+  try {
+    model.search.query = new RegExp(escapeRegex(styledSample), "gi");
+  } catch {
+    model.search.query = null;
+  }
+  model.search.matchIndex = -1;
+}
+function searchDone(search) {
+  search.active = false;
+  search.query = null;
+  search.matchIndex = -1;
+  search.matchString = "";
+  search.matchHighlightStr = "";
+}
+function searchNextMatch(model) {
+  if (!model.search.query) return;
+  const matches = [...model.content.matchAll(model.search.query)];
+  if (matches.length === 0) return;
+  if (model.search.matchHighlightStr && model.search.matchString) {
+    model.content = model.content.replace(model.search.matchHighlightStr, model.search.matchString);
+  }
+  model.search.matchIndex = (model.search.matchIndex + 1) % matches.length;
+  const match = matches[model.search.matchIndex];
+  model.search.matchString = match[0];
+  model.search.matchHighlightStr = model.matchHighlightStyle.render(
+    model.search.input.value()
+  );
+  model.content = model.content.substring(0, match.index) + model.search.matchHighlightStr + model.content.substring(match.index + match[0].length);
+  model.viewport.setContent(model.content);
+  const beforeMatch = model.content.substring(0, match.index);
+  const line = beforeMatch.split("\n").length - 1;
+  model.viewport.setYOffset(Math.max(0, line - Math.floor(model.viewport.height() / 2)));
+}
+function searchPrevMatch(model) {
+  if (!model.search.query) return;
+  const matches = [...model.content.matchAll(model.search.query)];
+  if (matches.length === 0) return;
+  if (model.search.matchHighlightStr && model.search.matchString) {
+    model.content = model.content.replace(model.search.matchHighlightStr, model.search.matchString);
+  }
+  model.search.matchIndex = model.search.matchIndex <= 0 ? matches.length - 1 : model.search.matchIndex - 1;
+  const match = matches[model.search.matchIndex];
+  model.search.matchString = match[0];
+  model.search.matchHighlightStr = model.matchHighlightStyle.render(
+    model.search.input.value()
+  );
+  model.content = model.content.substring(0, match.index) + model.search.matchHighlightStr + model.content.substring(match.index + match[0].length);
+  model.viewport.setContent(model.content);
+  const beforeMatch = model.content.substring(0, match.index);
+  const line = beforeMatch.split("\n").length - 1;
+  model.viewport.setYOffset(Math.max(0, line - Math.floor(model.viewport.height() / 2)));
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createModel5(parsed) {
+  const flags = parsed.flags;
+  let content = "";
+  if (parsed.args.length > 0) {
+    content = parsed.args[0];
+  } else if (!isStdinEmpty()) {
+    content = readStdin();
+    content = content.replace(/.\x08/g, "");
+  }
+  const showLineNumbers = flagBool(flags, "show-line-numbers", true);
+  const softWrap = flagBool(flags, "soft-wrap", true);
+  const lineNumberStyle = toLipgloss(extractStyleOptions(flags, "line-number"));
+  const lineNumberFg = flagStr(flags, "line-number.foreground", "237");
+  const lnStyle = lineNumberFg === "237" && !flags["line-number.foreground"] ? (0, import_lipgloss5.newStyle)().foreground("237") : lineNumberStyle;
+  const matchOpts = extractStyleOptions(flags, "match");
+  const matchStyle = matchOpts.foreground || matchOpts.bold ? toLipgloss(matchOpts) : (0, import_lipgloss5.newStyle)().foreground("212").bold(true);
+  const mhOpts = extractStyleOptions(flags, "match-highlight");
+  const matchHighlightStyle = mhOpts.foreground || mhOpts.background || mhOpts.bold ? toLipgloss(mhOpts) : (0, import_lipgloss5.newStyle)().foreground("235").background("225").bold(true);
+  const borderFg = flagStr(flags, "border-foreground", "212");
+  const vpStyle = (0, import_lipgloss5.newStyle)().border((0, import_lipgloss5.roundedBorder)()).borderForeground(borderFg).paddingRight(1).paddingLeft(1);
+  const viewport = (0, import_bubbles4.newViewport)();
+  viewport.softWrap = softWrap;
+  viewport.style = vpStyle;
+  const search = {
+    active: false,
+    input: (0, import_bubbles4.newTextInput)(),
+    query: null,
+    matchIndex: -1,
+    matchString: "",
+    matchHighlightStr: ""
+  };
+  return {
+    viewport,
+    content,
+    origContent: content,
+    showLineNumbers,
+    lineNumberStyle: lnStyle,
+    softWrap,
+    search,
+    matchStyle,
+    matchHighlightStyle,
+    maxWidth: 0,
+    aborted: false,
+    quitting: false,
+    viewportStyle: vpStyle,
+    init() {
+      return null;
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea5.WindowSizeMsg) {
+        this.viewport.setWidth(msg.width);
+        this.viewport.setHeight(msg.height - 2);
+        processText(this);
+        return [this, null];
+      }
+      if (msg instanceof import_bubbletea5.KeyPressMsg) {
+        if (this.search.active) {
+          if (msg.code === import_bubbletea5.KeyCode.Enter) {
+            if (this.search.input.value()) {
+              searchExecute(this);
+              this.search.active = false;
+            } else {
+              searchDone(this.search);
+              this.content = this.origContent;
+              processText(this);
+            }
+            return [this, null];
+          }
+          if (msg.code === import_bubbletea5.KeyCode.Escape || msg.mod & import_bubbletea5.KeyMod.Ctrl && msg.text === "c" || msg.mod & import_bubbletea5.KeyMod.Ctrl && msg.text === "d") {
+            searchDone(this.search);
+            this.content = this.origContent;
+            processText(this);
+            return [this, null];
+          }
+          const [updatedInput] = this.search.input.update(msg);
+          this.search.input = updatedInput;
+          return [this, null];
+        }
+        if (msg.text === "g" || msg.code === import_bubbletea5.KeyCode.Home) {
+          this.viewport.gotoTop();
+          return [this, null];
+        }
+        if (msg.text === "G" || msg.code === import_bubbletea5.KeyCode.End) {
+          this.viewport.gotoBottom();
+          return [this, null];
+        }
+        if (msg.text === "/") {
+          searchBegin(this.search);
+          return [this, null];
+        }
+        if (msg.text === "n") {
+          searchNextMatch(this);
+          return [this, null];
+        }
+        if (msg.text === "p" || msg.text === "N") {
+          searchPrevMatch(this);
+          return [this, null];
+        }
+        if (msg.text === "q" || msg.code === import_bubbletea5.KeyCode.Escape) {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea5.Quit)()];
+        }
+        if (msg.mod & import_bubbletea5.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea5.Quit)()];
+        }
+        const [updatedVp, vpCmd] = this.viewport.update(msg);
+        this.viewport = updatedVp;
+        return [this, vpCmd];
+      }
+      return [this, null];
+    },
+    view() {
+      if (this.quitting) return "";
+      if (this.search.active) {
+        return this.viewport.view() + "\n " + this.search.input.view();
+      }
+      return this.viewport.view() + "\n" + HELP_VIEW;
+    }
+  };
+}
+async function run8(parsed) {
+  const model = createModel5(parsed);
+  const p = new import_bubbletea5.Program(model, (0, import_bubbletea5.WithAltScreen)());
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+}
+
+// src/commands/spin.ts
+var import_bubbletea6 = require("@oakoliver/bubbletea");
+var import_bubbles5 = require("@oakoliver/bubbles");
+var import_node_child_process = require("node:child_process");
+var spinnerMap = {
+  line: import_bubbles5.Line,
+  dot: import_bubbles5.Dot,
+  minidot: import_bubbles5.MiniDot,
+  jump: import_bubbles5.Jump,
+  pulse: import_bubbles5.Pulse,
+  points: import_bubbles5.Points,
+  globe: import_bubbles5.Globe,
+  moon: import_bubbles5.Moon,
+  monkey: import_bubbles5.Monkey,
+  meter: import_bubbles5.Meter,
+  hamburger: import_bubbles5.Hamburger
+};
+var FinishCommandMsg = class {
+  constructor(output, exitCode) {
+    this.output = output;
+    this.exitCode = exitCode;
+  }
+  _tag = "FinishCommandMsg";
+};
+function runCommand(command) {
+  return () => new Promise((resolve2) => {
+    const child = (0, import_node_child_process.spawn)(command[0], command.slice(1), {
+      shell: true,
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2(new FinishCommandMsg(stdout || stderr, code ?? 1));
+    });
+    child.on("error", (err) => {
+      resolve2(new FinishCommandMsg(err.message, 1));
+    });
+  });
+}
+function createModel6(parsed) {
+  const flags = parsed.flags;
+  const spinnerName = flagStr(flags, "spinner", "dot");
+  const spinnerType = spinnerMap[spinnerName] || import_bubbles5.Dot;
+  const spinner = (0, import_bubbles5.newSpinner)();
+  spinner.spinner = spinnerType;
+  const title = flagStr(flags, "title", "Loading...");
+  const showOutput = flagBool(flags, "show-output", false);
+  const align = flagStr(flags, "align", "left");
+  const titleStyle = toLipgloss(extractStyleOptions(flags, "title"));
+  const spinnerStyle = toLipgloss(extractStyleOptions(flags, "spinner"));
+  spinner.style = spinnerStyle;
+  const command = parsed.args;
+  return {
+    spinner,
+    title,
+    titleStyle,
+    spinnerStyle,
+    command,
+    aborted: false,
+    quitting: false,
+    output: "",
+    exitCode: 0,
+    showOutput,
+    align,
+    init() {
+      const cmds = [];
+      cmds.push(() => this.spinner.tickMsg());
+      if (this.command.length > 0) {
+        cmds.push(runCommand(this.command));
+      }
+      return (0, import_bubbletea6.Batch)(...cmds);
+    },
+    update(msg) {
+      if (msg instanceof FinishCommandMsg) {
+        this.output = msg.output;
+        this.exitCode = msg.exitCode;
+        this.quitting = true;
+        return [this, () => (0, import_bubbletea6.Quit)()];
+      }
+      if (msg instanceof import_bubbletea6.KeyPressMsg) {
+        if (msg.mod & import_bubbletea6.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea6.Quit)()];
+        }
+      }
+      const [updatedSpinner, cmd] = this.spinner.update(msg);
+      this.spinner = updatedSpinner;
+      return [this, cmd];
+    },
+    view() {
+      if (this.quitting) return "";
+      let line;
+      const spinView = this.spinner.view();
+      const titleView = this.titleStyle.render(this.title);
+      if (this.align === "right") {
+        line = titleView + " " + spinView;
+      } else {
+        line = spinView + " " + titleView;
+      }
+      let out = line;
+      if (this.showOutput && this.output) {
+        out += "\n" + this.output;
+      }
+      return out;
+    }
+  };
+}
+async function run9(parsed) {
+  const model = createModel6(parsed);
+  if (model.command.length === 0) {
+    console.error("Error: no command provided. Usage: gum spin -- <command>");
+    process.exit(1);
+  }
+  const p = new import_bubbletea6.Program(model);
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+  if (final.output) {
+    process.stdout.write(final.output);
+    if (!final.output.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  }
+  process.exit(final.exitCode);
+}
+
+// src/commands/style.ts
+async function run10(parsed) {
+  const flags = parsed.flags;
+  const opts = {
+    foreground: flagStr(flags, "foreground", "") || void 0,
+    background: flagStr(flags, "background", "") || void 0,
+    border: flagStr(flags, "border", "") || void 0,
+    borderForeground: flagStr(flags, "border-foreground", "") || flagStr(flags, "border.foreground", "") || void 0,
+    borderBackground: flagStr(flags, "border-background", "") || flagStr(flags, "border.background", "") || void 0,
+    align: flagStr(flags, "align", "") || void 0,
+    height: flags["height"] !== void 0 ? parseInt(String(flags["height"]), 10) : void 0,
+    width: flags["width"] !== void 0 ? parseInt(String(flags["width"]), 10) : void 0,
+    margin: flagStr(flags, "margin", "") || void 0,
+    padding: flagStr(flags, "padding", "") || void 0,
+    bold: flags["bold"] === true || flags["bold"] === "true",
+    faint: flags["faint"] === true || flags["faint"] === "true",
+    italic: flags["italic"] === true || flags["italic"] === "true",
+    strikethrough: flags["strikethrough"] === true || flags["strikethrough"] === "true",
+    underline: flags["underline"] === true || flags["underline"] === "true"
+  };
+  const style = toLipgloss(opts);
+  let text;
+  if (parsed.args.length > 0) {
+    text = parsed.args.join(" ");
+  } else if (!isStdinEmpty()) {
+    text = readStdin();
+  } else {
+    text = "";
+  }
+  const result = style.render(text);
+  println(result);
+}
+
+// src/commands/table.ts
+var import_bubbletea7 = require("@oakoliver/bubbletea");
+var import_bubbles6 = require("@oakoliver/bubbles");
+var import_lipgloss6 = require("@oakoliver/lipgloss");
+var fs3 = __toESM(require("node:fs"), 1);
+function parseCSV(input, separator) {
+  const rows = [];
+  let i = 0;
+  const len = input.length;
+  while (i < len) {
+    const row = [];
+    while (i < len) {
+      if (input[i] === '"') {
+        i++;
+        let field = "";
+        while (i < len) {
+          if (input[i] === '"') {
+            if (i + 1 < len && input[i + 1] === '"') {
+              field += '"';
+              i += 2;
+            } else {
+              i++;
+              break;
+            }
+          } else {
+            field += input[i];
+            i++;
+          }
+        }
+        row.push(field);
+      } else {
+        let field = "";
+        while (i < len && input[i] !== separator && input[i] !== "\n" && input[i] !== "\r") {
+          field += input[i];
+          i++;
+        }
+        row.push(field);
+      }
+      if (i < len && input[i] === separator) {
+        i++;
+      } else {
+        break;
+      }
+    }
+    if (i < len && input[i] === "\r") i++;
+    if (i < len && input[i] === "\n") i++;
+    if (row.length === 1 && row[0] === "" && i >= len) break;
+    rows.push(row);
+  }
+  return rows;
+}
+function writeCSV(row, separator) {
+  return row.map((field) => {
+    if (field.includes(separator) || field.includes('"') || field.includes("\n")) {
+      return '"' + field.replace(/"/g, '""') + '"';
+    }
+    return field;
+  }).join(separator);
+}
+function createModel7(table, showHelp) {
+  return {
+    table,
+    aborted: false,
+    quitting: false,
+    showHelp,
+    init() {
+      this.table.focus();
+      return null;
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea7.WindowSizeMsg) {
+        this.table.setWidth(msg.width);
+        this.table.setHeight(msg.height - 2);
+        this.table.updateViewport();
+        return [this, null];
+      }
+      if (msg instanceof import_bubbletea7.KeyPressMsg) {
+        if (msg.mod & import_bubbletea7.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea7.Quit)()];
+        }
+        if (msg.code === import_bubbletea7.KeyCode.Escape || msg.text === "q" || msg.mod & import_bubbletea7.KeyMod.Ctrl && msg.text === "q") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea7.Quit)()];
+        }
+        if (msg.code === import_bubbletea7.KeyCode.Enter) {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea7.Quit)()];
+        }
+      }
+      const [updated, cmd] = this.table.update(msg);
+      this.table = updated;
+      return [this, cmd];
+    },
+    view() {
+      if (this.quitting) return "";
+      let out = this.table.view();
+      const total = this.table.rows().length;
+      const current = this.table.cursor() + 1;
+      const counter = `  ${current}/${total}`;
+      if (this.showHelp) {
+        out += "\n" + (0, import_lipgloss6.newStyle)().faint(true).render(
+          "\u2191/\u2193: navigate \u2022 enter: select \u2022 q/esc: quit"
+        ) + counter;
+      } else {
+        out += "\n" + counter;
+      }
+      return out;
+    }
+  };
+}
+async function run11(parsed) {
+  const flags = parsed.flags;
+  const separator = flagStr(flags, "separator", ",");
+  const colFlag = flagStr(flags, "columns", "");
+  const widthsFlag = flagStr(flags, "widths", "");
+  const height = flagInt(flags, "height", 0);
+  const printMode = flagBool(flags, "print", false);
+  const filePath = flagStr(flags, "file", "");
+  const showHelp = flagBool(flags, "show-help", true);
+  const returnColumn = flagInt(flags, "return-column", 0);
+  let input = "";
+  if (filePath) {
+    input = fs3.readFileSync(filePath, "utf-8");
+  } else if (!isStdinEmpty()) {
+    input = readStdin();
+  } else {
+    console.error("Error: no input provided (pipe data or use --file)");
+    process.exit(1);
+  }
+  const allRows = parseCSV(input, separator);
+  if (allRows.length === 0) {
+    console.error("Error: no data");
+    process.exit(1);
+  }
+  let headers;
+  let dataRows;
+  if (colFlag) {
+    headers = colFlag.split(",");
+    dataRows = allRows;
+  } else {
+    headers = allRows[0];
+    dataRows = allRows.slice(1);
+  }
+  const explicitWidths = widthsFlag ? widthsFlag.split(",").map((w) => parseInt(w, 10)) : [];
+  const columns = headers.map((title, i) => {
+    if (explicitWidths[i] && explicitWidths[i] > 0) {
+      return { title, width: explicitWidths[i] };
+    }
+    let maxW = (0, import_lipgloss6.stringWidth)(title);
+    for (const row of dataRows) {
+      if (row[i] !== void 0) {
+        maxW = Math.max(maxW, (0, import_lipgloss6.stringWidth)(row[i]));
+      }
+    }
+    return { title, width: maxW + 2 };
+  });
+  const cellOpts = extractStyleOptions(flags, "cell");
+  const headerOpts = extractStyleOptions(flags, "header");
+  const selectedOpts = extractStyleOptions(flags, "selected");
+  if (!selectedOpts.foreground) selectedOpts.foreground = "212";
+  const baseStyles = (0, import_bubbles6.tableDefaultStyles)();
+  const styles = {
+    cell: toLipgloss(cellOpts).inherit(baseStyles.cell),
+    header: toLipgloss(headerOpts).inherit(baseStyles.header),
+    selected: toLipgloss(selectedOpts).inherit(baseStyles.selected)
+  };
+  const tableHeight = height > 0 ? height : Math.min(dataRows.length, 20);
+  const table = (0, import_bubbles6.newTable)(
+    (0, import_bubbles6.withColumns)(columns),
+    (0, import_bubbles6.withRows)(dataRows),
+    (0, import_bubbles6.withTableFocused)(true),
+    (0, import_bubbles6.withTableStyles)(styles),
+    (0, import_bubbles6.withTableHeight)(tableHeight)
+  );
+  if (printMode) {
+    println(table.view());
+    return;
+  }
+  const model = createModel7(table, showHelp);
+  const p = new import_bubbletea7.Program(model);
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+  const selected = final.table.selectedRow();
+  if (!selected || selected.length === 0) return;
+  if (returnColumn > 0 && returnColumn <= selected.length) {
+    println(selected[returnColumn - 1]);
+  } else {
+    println(writeCSV(selected, separator));
+  }
+}
+
+// src/commands/write.ts
+var import_bubbletea8 = require("@oakoliver/bubbletea");
+var import_bubbles7 = require("@oakoliver/bubbles");
+function createModel8(parsed) {
+  const flags = parsed.flags;
+  const ta = (0, import_bubbles7.newTextarea)();
+  ta.placeholder = flagWithEnv(flags, "placeholder", "GUM_WRITE_PLACEHOLDER", "Write something...");
+  ta.prompt = flagStr(flags, "prompt", "\u2503 ");
+  const value = flagStr(flags, "value", "");
+  if (value) ta.setValue(value);
+  const charLimit = flagInt(flags, "char-limit", 400);
+  ta.charLimit = charLimit > 0 ? charLimit : 0;
+  const showLineNumbers = flagBool(flags, "show-line-numbers", false);
+  ta.showLineNumbers = showLineNumbers;
+  const widthFlag = flagInt(flags, "width", 0);
+  const heightFlag = flagInt(flags, "height", 10);
+  const autoWidth = widthFlag === 0;
+  const autoHeight = heightFlag === 0;
+  if (!autoWidth) {
+    ta.setWidth(widthFlag);
+  }
+  if (!autoHeight) {
+    ta.setHeight(heightFlag);
+  }
+  const header = flagStr(flags, "header", "");
+  const headerStyle = toLipgloss(extractStyleOptions(flags, "header"));
+  const cursorFg = flagStr(flags, "cursor.foreground", "");
+  if (cursorFg) {
+    const styles = ta.getStyles();
+    styles.cursor.color = cursorFg;
+    ta.setStyles(styles);
+  }
+  const baseStyleOpts = extractStyleOptions(flags, "base");
+  if (Object.values(baseStyleOpts).some((v) => v !== void 0 && v !== false && v !== "")) {
+    const styles = ta.getStyles();
+    const baseStyle = toLipgloss(baseStyleOpts);
+    styles.focused.base = baseStyle;
+    ta.setStyles(styles);
+  }
+  ta.focus();
+  return {
+    textarea: ta,
+    aborted: false,
+    quitting: false,
+    header,
+    headerStyle,
+    autoWidth,
+    autoHeight,
+    width: widthFlag || 80,
+    init() {
+      return null;
+    },
+    update(msg) {
+      if (msg instanceof import_bubbletea8.WindowSizeMsg) {
+        this.width = msg.width;
+        if (this.autoWidth) {
+          this.textarea.setWidth(msg.width);
+        }
+        if (this.autoHeight) {
+          this.textarea.setHeight(msg.height - 2);
+        }
+        return [this, null];
+      }
+      if (msg instanceof import_bubbletea8.KeyPressMsg) {
+        if (msg.mod & import_bubbletea8.KeyMod.Ctrl && msg.text === "c") {
+          this.aborted = true;
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea8.Quit)()];
+        }
+        if (msg.code === import_bubbletea8.KeyCode.Escape) {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea8.Quit)()];
+        }
+        if (msg.mod & import_bubbletea8.KeyMod.Ctrl && msg.text === "d") {
+          this.quitting = true;
+          return [this, () => (0, import_bubbletea8.Quit)()];
+        }
+      }
+      const [updatedTa, cmd] = this.textarea.update(msg);
+      this.textarea = updatedTa;
+      return [this, cmd];
+    },
+    view() {
+      if (this.quitting) return "";
+      let out = "";
+      if (this.header) {
+        out += this.headerStyle.render(this.header) + "\n";
+      }
+      out += this.textarea.view();
+      return out;
+    }
+  };
+}
+async function run12(parsed) {
+  const model = createModel8(parsed);
+  const p = new import_bubbletea8.Program(model);
+  const final = await p.run();
+  if (final.aborted) {
+    process.exit(STATUS_ABORTED);
+  }
+  process.stdout.write(final.textarea.value() + "\n");
+}
+
+// src/internal/files.ts
+var fs4 = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var defaultIgnorePatterns = ["node_modules", ".git", "."];
+function shouldIgnore(filePath) {
+  for (const prefix of defaultIgnorePatterns) {
+    if (filePath.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function listFiles(dir = ".") {
+  const files = [];
+  function walk(currentDir) {
+    let entries;
+    try {
+      entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const relativePath = path.join(currentDir, entry.name);
+      if (shouldIgnore(relativePath) || shouldIgnore(entry.name)) continue;
+      if (entry.isDirectory()) {
+        walk(relativePath);
+      } else if (entry.isFile()) {
+        files.push(relativePath);
+      }
+    }
+  }
+  walk(dir);
+  return files;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exactMatches,
+  extractStyleOptions,
+  flagBool,
+  flagInt,
+  flagStr,
+  flagWithEnv,
+  fuzzyFind,
+  fuzzyFindNoSort,
+  isStdinEmpty,
+  listFiles,
+  matchAll,
+  matchedRanges,
+  parseArgs,
+  parsePadding,
+  readStdin,
+  runChoose,
+  runConfirm,
+  runFile,
+  runFormat,
+  runInput,
+  runJoin,
+  runLog,
+  runPager,
+  runSpin,
+  runStyle,
+  runTable,
+  runWrite,
+  stripAnsi,
+  toLipgloss
+});