@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.1

package/src/service/shutdown/DefaultShutdownService.ts

@@ -1,4 +1,5 @@
 import type ShutdownService from "../../api/service/core/ShutdownService.ts";
+import { shutdownState } from "./ShutdownState.ts";
 
 export default class DefaultShutdownService implements ShutdownService {
   static readonly callbacks: Array<() => Promise<void>> = [];
@@ -6,4 +7,16 @@ export default class DefaultShutdownService implements ShutdownService {
   addShutdownListener(callback: () => Promise<void>): void {
     DefaultShutdownService.callbacks.push(callback);
   }
+
+  enterLongRunningMode(): void {
+    shutdownState.longRunningMode = true;
+  }
+
+  leaveLongRunningMode(): void {
+    shutdownState.longRunningMode = false;
+  }
+
+  get isShutdownRequested(): boolean {
+    return shutdownState.shutdownRequested;
+  }
 }

package/src/service/shutdown/ShutdownServiceProvider.ts

@@ -9,29 +9,25 @@ import { SHUTDOWN_SERVICE_ID } from "../../api/service/core/ShutdownService.ts";
 import type Context from "../../api/Context.ts";
 import getLogger from "../../util/logger.ts";
 import type CLIConfig from "../../api/CLIConfig.ts";
+import { shutdownState } from "./ShutdownState.ts";
 
 const logger = getLogger("ShutdownServiceProvider");
 
-/**
- * Provides a {@link ShutdownService}.
- */
 export default class ShutdownServiceProvider implements ServiceProvider {
   readonly serviceId: string = SHUTDOWN_SERVICE_ID;
   readonly #shutdownService: ShutdownService;
+  static #shutdownInProgress = false;
 
-  /**
-   * Create an instance of the service provider with the specified details.
-   *
-   * @param servicePriority the priority of the service.
-   */
   public constructor(
     readonly servicePriority: number,
   ) {
     this.#shutdownService = new DefaultShutdownService();
     process.on("beforeExit", ShutdownServiceProvider.shutdown);
+    process.on("SIGINT", ShutdownServiceProvider.onInterrupt);
+    process.on("SIGTERM", ShutdownServiceProvider.onTerminate);
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.#shutdownService,
       commands: [],
@@ -42,9 +38,32 @@ export default class ShutdownServiceProvider implements ServiceProvider {
     return Promise.resolve(undefined);
   }
 
+  static onInterrupt(): void {
+    shutdownState.interruptCount++;
+    if (
+      !shutdownState.longRunningMode || shutdownState.interruptCount >= 3
+    ) {
+      ShutdownServiceProvider.shutdown().then(() => {
+        process.exit(130);
+      });
+    } else {
+      shutdownState.shutdownRequested = true;
+    }
+  }
+
+  static onTerminate(): void {
+    ShutdownServiceProvider.shutdown().then(() => {
+      process.exit(143);
+    });
+  }
+
   static async shutdown() {
+    if (ShutdownServiceProvider.#shutdownInProgress) return;
+    ShutdownServiceProvider.#shutdownInProgress = true;
     try {
       process.removeListener("beforeExit", ShutdownServiceProvider.shutdown);
+      process.removeListener("SIGINT", ShutdownServiceProvider.onInterrupt);
+      process.removeListener("SIGTERM", ShutdownServiceProvider.onTerminate);
       for await (const callback of DefaultShutdownService.callbacks) {
         await callback();
       }

package/src/service/shutdown/ShutdownState.ts

@@ -0,0 +1,5 @@
+export const shutdownState = {
+  longRunningMode: false,
+  shutdownRequested: false,
+  interruptCount: 0,
+};

package/src/service/syntaxHighlighter/SyntaxHighlighterServiceProvider.ts

@@ -31,7 +31,7 @@ export default class SyntaxHighlighterServiceProvider
       new DefaultSyntaxHighlighterService();
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.#defaultSyntaxHighlighterService,
       commands: [],

package/src/service/tableGenerator/DefaultTableGeneratorService.ts

@@ -0,0 +1,415 @@
+import type TableGeneratorService from "../../api/service/core/TableGeneratorService.ts";
+import { Align } from "../../api/service/core/TableGeneratorService.ts";
+import type Table from "../../api/service/core/Table.ts";
+
+const BORDER_TOP_LEFT = "┌";
+const BORDER_TOP = "─";
+const BORDER_TOP_MIDDLE = "┬";
+const BORDER_TOP_RIGHT = "┐";
+const BORDER_LEFT = "│";
+const BORDER_MIDDLE_VERTICAL = "│";
+const BORDER_RIGHT = "│";
+const BORDER_LEFT_MIDDLE = "├";
+const BORDER_MIDDLE = "─";
+const BORDER_MIDDLE_MIDDLE = "┼";
+const BORDER_RIGHT_MIDDLE = "┤";
+const BORDER_BOTTOM_LEFT = "└";
+const BORDER_BOTTOM = "─";
+const BORDER_BOTTOM_MIDDLE = "┴";
+const BORDER_BOTTOM_RIGHT = "┘";
+
+export default class DefaultTableGeneratorService
+  implements TableGeneratorService {
+  colorEnabled = true;
+  colorFunction: (text: string, hexFormattedColor: string) => string = (
+    text,
+  ) => text;
+  backgroundColorFunction: (text: string, hexFormattedColor: string) => string =
+    (text) => text;
+
+  #resolveAlign(
+    table: Table,
+    rowIndex: number,
+    columnIndex: number,
+  ): Align {
+    const cellOpts = table.getCell(rowIndex, columnIndex)?.options;
+    if (cellOpts?.align !== undefined) return cellOpts.align;
+    const rowOpts = table.getRowOptions(rowIndex);
+    if (rowOpts?.align !== undefined) return rowOpts.align;
+    const colOpts = table.getColumnOptions(columnIndex);
+    if (colOpts?.align !== undefined) return colOpts.align;
+    return table.options.align ?? Align.LEFT;
+  }
+
+  #calculateColumnWidths(table: Table): number[] {
+    const border = table.options.border !== false;
+    const padding = table.options.padding ?? 1;
+    const maxWidth = table.options.maxWidth ?? 80;
+
+    const borderOverhead = border
+      ? table.columnCount + 1
+      : Math.max(table.columnCount - 1, 0);
+    const paddingOverhead = table.columnCount * 2 * padding;
+    const contentBudget = Math.max(
+      maxWidth - borderOverhead - paddingOverhead,
+      table.columnCount,
+    );
+
+    const naturalWidths: number[] = [];
+    for (let col = 0; col < table.columnCount; col++) {
+      let maxCellWidth = 0;
+      for (let row = 0; row < table.rowCount; row++) {
+        const cell = table.getCell(row, col);
+        if (cell) {
+          const lines = cell.contents.split("\n");
+          for (const line of lines) {
+            const w = Bun.stringWidth(line);
+            if (w > maxCellWidth) maxCellWidth = w;
+          }
+        }
+      }
+      const colOpts = table.getColumnOptions(col);
+      if (colOpts?.minWidth !== undefined && maxCellWidth < colOpts.minWidth) {
+        maxCellWidth = colOpts.minWidth;
+      }
+      if (colOpts?.maxWidth !== undefined && maxCellWidth > colOpts.maxWidth) {
+        maxCellWidth = colOpts.maxWidth;
+      }
+      naturalWidths.push(maxCellWidth);
+    }
+
+    const totalNatural = naturalWidths.reduce((a, b) => a + b, 0);
+
+    if (totalNatural <= contentBudget) {
+      const surplus = contentBudget - totalNatural;
+      const totalFlexWeight = this.#sumFlexWeights(table);
+      if (surplus > 0 && totalFlexWeight > 0) {
+        this.#distributeGrow(table, naturalWidths, surplus, totalFlexWeight);
+      }
+    } else {
+      const excess = totalNatural - contentBudget;
+      this.#distributeShrink(table, naturalWidths, excess);
+    }
+
+    return naturalWidths;
+  }
+
+  #sumFlexWeights(table: Table): number {
+    let total = 0;
+    for (let col = 0; col < table.columnCount; col++) {
+      const colOpts = table.getColumnOptions(col);
+      total += colOpts?.flexWeight ?? 0;
+    }
+    return total;
+  }
+
+  #distributeGrow(
+    table: Table,
+    widths: number[],
+    surplus: number,
+    totalFlexWeight: number,
+  ): void {
+    let remaining = surplus;
+    for (let col = 0; col < table.columnCount; col++) {
+      const colOpts = table.getColumnOptions(col);
+      const weight = colOpts?.flexWeight ?? 0;
+      if (weight <= 0) continue;
+      const share = Math.floor((weight / totalFlexWeight) * surplus);
+      let newWidth = widths[col]! + share;
+      if (colOpts?.maxWidth !== undefined && newWidth > colOpts.maxWidth) {
+        newWidth = colOpts.maxWidth;
+      }
+      const added = newWidth - widths[col]!;
+      widths[col] = newWidth;
+      remaining -= added;
+    }
+    // distribute any rounding remainder to first flex column
+    if (remaining > 0) {
+      for (let col = 0; col < table.columnCount; col++) {
+        const colOpts = table.getColumnOptions(col);
+        if ((colOpts?.flexWeight ?? 0) > 0) {
+          let newWidth = widths[col]! + remaining;
+          if (colOpts?.maxWidth !== undefined && newWidth > colOpts.maxWidth) {
+            newWidth = colOpts.maxWidth;
+          }
+          widths[col] = newWidth;
+          break;
+        }
+      }
+    }
+  }
+
+  #distributeShrink(
+    table: Table,
+    widths: number[],
+    excess: number,
+  ): void {
+    let remaining = excess;
+    const shrinkable = new Set<number>();
+    for (let col = 0; col < table.columnCount; col++) {
+      const colOpts = table.getColumnOptions(col);
+      if ((colOpts?.flexWeight ?? 0) > 0) {
+        shrinkable.add(col);
+      }
+    }
+
+    while (remaining > 0 && shrinkable.size > 0) {
+      let totalWeightedWidth = 0;
+      for (const col of shrinkable) {
+        const colOpts = table.getColumnOptions(col);
+        totalWeightedWidth += (colOpts?.flexWeight ?? 0) * widths[col]!;
+      }
+      if (totalWeightedWidth <= 0) break;
+
+      let shrank = false;
+      for (const col of shrinkable) {
+        if (remaining <= 0) break;
+        const colOpts = table.getColumnOptions(col);
+        const weight = colOpts?.flexWeight ?? 0;
+        const share = Math.max(
+          1,
+          Math.floor(
+            (weight * widths[col]! / totalWeightedWidth) * remaining,
+          ),
+        );
+        const minWidth = colOpts?.minWidth ?? 1;
+        const maxShrink = widths[col]! - minWidth;
+        if (maxShrink <= 0) {
+          shrinkable.delete(col);
+          continue;
+        }
+        const actual = Math.min(share, maxShrink);
+        widths[col] = widths[col]! - actual;
+        remaining -= actual;
+        shrank = true;
+        if (widths[col]! <= minWidth) {
+          shrinkable.delete(col);
+        }
+      }
+      if (!shrank) break;
+    }
+  }
+
+  #wrapLine(line: string, width: number): string[] {
+    if (width <= 0) return [line];
+    if (Bun.stringWidth(line) <= width) return [line];
+
+    const wrapped: string[] = [];
+    const words = line.split(/(\s+)/);
+    let currentLine = "";
+    let currentWidth = 0;
+
+    for (const word of words) {
+      const wordWidth = Bun.stringWidth(word);
+      if (currentWidth === 0) {
+        if (wordWidth <= width) {
+          currentLine = word;
+          currentWidth = wordWidth;
+        } else {
+          this.#hardBreak(word, width, wrapped);
+          currentLine = "";
+          currentWidth = 0;
+          if (wrapped.length > 0) {
+            const last = wrapped[wrapped.length - 1]!;
+            if (Bun.stringWidth(last) < width) {
+              currentLine = wrapped.pop()!;
+              currentWidth = Bun.stringWidth(currentLine);
+            }
+          }
+        }
+      } else if (currentWidth + wordWidth <= width) {
+        currentLine += word;
+        currentWidth += wordWidth;
+      } else {
+        wrapped.push(currentLine);
+        const trimmed = word.replace(/^\s+/, "");
+        const trimmedWidth = Bun.stringWidth(trimmed);
+        if (trimmedWidth <= width) {
+          currentLine = trimmed;
+          currentWidth = trimmedWidth;
+        } else {
+          this.#hardBreak(trimmed, width, wrapped);
+          currentLine = "";
+          currentWidth = 0;
+          if (wrapped.length > 0) {
+            const last = wrapped[wrapped.length - 1]!;
+            if (Bun.stringWidth(last) < width) {
+              currentLine = wrapped.pop()!;
+              currentWidth = Bun.stringWidth(currentLine);
+            }
+          }
+        }
+      }
+    }
+    if (currentLine.length > 0) {
+      wrapped.push(currentLine);
+    }
+    return wrapped.length > 0 ? wrapped : [""];
+  }
+
+  #hardBreak(text: string, width: number, output: string[]): void {
+    let remaining = text;
+    while (Bun.stringWidth(remaining) > width) {
+      let breakAt = 0;
+      let w = 0;
+      for (const char of remaining) {
+        const cw = Bun.stringWidth(char);
+        if (w + cw > width) break;
+        w += cw;
+        breakAt += char.length;
+      }
+      if (breakAt === 0) breakAt = 1;
+      output.push(remaining.slice(0, breakAt));
+      remaining = remaining.slice(breakAt);
+    }
+    if (remaining.length > 0) {
+      output.push(remaining);
+    }
+  }
+
+  #wrapCellContent(contents: string, width: number): string[] {
+    const inputLines = contents.split("\n");
+    const result: string[] = [];
+    for (const line of inputLines) {
+      result.push(...this.#wrapLine(line, width));
+    }
+    return result.length > 0 ? result : [""];
+  }
+
+  #alignText(text: string, width: number, align: Align): string {
+    const textWidth = Bun.stringWidth(text);
+    const gap = width - textWidth;
+    if (gap <= 0) return text;
+    switch (align) {
+      case Align.LEFT:
+        return text + " ".repeat(gap);
+      case Align.RIGHT:
+        return " ".repeat(gap) + text;
+      case Align.CENTER: {
+        const left = Math.floor(gap / 2);
+        const right = gap - left;
+        return " ".repeat(left) + text + " ".repeat(right);
+      }
+    }
+  }
+
+  #colorBorder(char: string, table: Table): string {
+    let result = char;
+    if (this.colorEnabled && table.options.borderBackgroundColor) {
+      result = this.backgroundColorFunction(
+        result,
+        table.options.borderBackgroundColor,
+      );
+    }
+    if (this.colorEnabled && table.options.borderColor) {
+      result = this.colorFunction(result, table.options.borderColor);
+    }
+    return result;
+  }
+
+  render(table: Table): string {
+    const border = table.options.border !== false;
+    const padding = table.options.padding ?? 1;
+    const columnWidths = this.#calculateColumnWidths(table);
+    const pad = " ".repeat(padding);
+
+    const wrappedCells: string[][][] = [];
+    const rowHeights: number[] = [];
+    for (let row = 0; row < table.rowCount; row++) {
+      const rowCells: string[][] = [];
+      let maxHeight = 1;
+      for (let col = 0; col < table.columnCount; col++) {
+        const cell = table.getCell(row, col);
+        const lines = this.#wrapCellContent(
+          cell?.contents ?? "",
+          columnWidths[col]!,
+        );
+        rowCells.push(lines);
+        if (lines.length > maxHeight) maxHeight = lines.length;
+      }
+      wrappedCells.push(rowCells);
+      rowHeights.push(maxHeight);
+    }
+
+    const output: string[] = [];
+
+    if (border) {
+      output.push(this.#renderHorizontalBorder(
+        table,
+        columnWidths,
+        padding,
+        BORDER_TOP_LEFT,
+        BORDER_TOP,
+        BORDER_TOP_MIDDLE,
+        BORDER_TOP_RIGHT,
+      ));
+    }
+
+    for (let row = 0; row < table.rowCount; row++) {
+      for (let subLine = 0; subLine < rowHeights[row]!; subLine++) {
+        let line = "";
+        if (border) line += this.#colorBorder(BORDER_LEFT, table);
+        for (let col = 0; col < table.columnCount; col++) {
+          if (!border && col > 0) line += " ".repeat(padding * 2);
+          const cellLines = wrappedCells[row]![col]!;
+          const content = subLine < cellLines.length ? cellLines[subLine]! : "";
+          const align = this.#resolveAlign(table, row, col);
+          const aligned = this.#alignText(content, columnWidths[col]!, align);
+          line += pad + aligned + pad;
+          if (border && col < table.columnCount - 1) {
+            line += this.#colorBorder(BORDER_MIDDLE_VERTICAL, table);
+          }
+        }
+        if (border) line += this.#colorBorder(BORDER_RIGHT, table);
+        output.push(line);
+      }
+
+      if (border && row < table.rowCount - 1) {
+        output.push(this.#renderHorizontalBorder(
+          table,
+          columnWidths,
+          padding,
+          BORDER_LEFT_MIDDLE,
+          BORDER_MIDDLE,
+          BORDER_MIDDLE_MIDDLE,
+          BORDER_RIGHT_MIDDLE,
+        ));
+      }
+    }
+
+    if (border) {
+      output.push(this.#renderHorizontalBorder(
+        table,
+        columnWidths,
+        padding,
+        BORDER_BOTTOM_LEFT,
+        BORDER_BOTTOM,
+        BORDER_BOTTOM_MIDDLE,
+        BORDER_BOTTOM_RIGHT,
+      ));
+    }
+
+    return output.join("\n");
+  }
+
+  #renderHorizontalBorder(
+    table: Table,
+    columnWidths: number[],
+    padding: number,
+    left: string,
+    horizontal: string,
+    middle: string,
+    right: string,
+  ): string {
+    let line = this.#colorBorder(left, table);
+    for (let col = 0; col < table.columnCount; col++) {
+      const segment = horizontal.repeat(columnWidths[col]! + padding * 2);
+      line += this.#colorBorder(segment, table);
+      if (col < table.columnCount - 1) {
+        line += this.#colorBorder(middle, table);
+      }
+    }
+    line += this.#colorBorder(right, table);
+    return line;
+  }
+}

package/src/service/tableGenerator/TableGeneratorServiceProvider.ts

@@ -0,0 +1,43 @@
+import type {
+  ServiceInfo,
+  ServiceProvider,
+} from "../../api/service/ServiceProvider.ts";
+import DefaultTableGeneratorService from "./DefaultTableGeneratorService.ts";
+import { TABLE_GENERATOR_SERVICE_ID } from "../../api/service/core/TableGeneratorService.ts";
+import type Context from "../../api/Context.ts";
+import type PrinterService from "../../api/service/core/PrinterService.ts";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.ts";
+import type CLIConfig from "../../api/CLIConfig.ts";
+
+export default class TableGeneratorServiceProvider implements ServiceProvider {
+  readonly serviceId: string = TABLE_GENERATOR_SERVICE_ID;
+  readonly #defaultTableGeneratorService: DefaultTableGeneratorService;
+
+  public constructor(
+    readonly servicePriority: number,
+  ) {
+    this.#defaultTableGeneratorService = new DefaultTableGeneratorService();
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    return Promise.resolve({
+      service: this.#defaultTableGeneratorService,
+      commands: [],
+    });
+  }
+
+  initService(context: Context): Promise<void> {
+    const printerService = context.getServiceById(
+      PRINTER_SERVICE_ID,
+    ) as PrinterService;
+
+    this.#defaultTableGeneratorService.colorEnabled =
+      printerService.colorEnabled;
+    this.#defaultTableGeneratorService.colorFunction = printerService.color
+      .bind(printerService);
+    this.#defaultTableGeneratorService.backgroundColorFunction = printerService
+      .backgroundColor.bind(printerService);
+
+    return Promise.resolve(undefined);
+  }
+}

package/src/service/treePrinter/DefaultTreePrinterService.ts

@@ -0,0 +1,49 @@
+import type TreePrinterService from "../../api/service/core/TreePrinterService.ts";
+import type { TreeNode } from "../../api/service/core/TreePrinterService.ts";
+
+const DEFAULT_NODE_COLOR = "#839496";
+
+export default class DefaultTreePrinterService implements TreePrinterService {
+  colorEnabled = true;
+  colorFunction: (text: string, hexFormattedColor: string) => string = (text) =>
+    text;
+
+  readonly #nodeColor: string;
+
+  constructor(nodeColor: string = DEFAULT_NODE_COLOR) {
+    this.#nodeColor = nodeColor;
+  }
+
+  #colorLabel(label: string): string {
+    if (this.colorEnabled) {
+      return this.colorFunction(label, this.#nodeColor);
+    }
+    return label;
+  }
+
+  #renderChildren(
+    children: Array<TreeNode | string>,
+    prefix: string,
+    lines: string[],
+  ): void {
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i]!;
+      const isLast = i === children.length - 1;
+      const connector = isLast ? "└── " : "├── ";
+      const extension = isLast ? "    " : "│   ";
+
+      if (typeof child === "string") {
+        lines.push(prefix + connector + this.#colorLabel(child));
+      } else {
+        lines.push(prefix + connector + this.#colorLabel(child.label));
+        this.#renderChildren(child.children ?? [], prefix + extension, lines);
+      }
+    }
+  }
+
+  print(node: TreeNode): string {
+    const lines: string[] = [this.#colorLabel(node.label)];
+    this.#renderChildren(node.children ?? [], "", lines);
+    return lines.join("\n");
+  }
+}

package/src/service/treePrinter/TreePrinterServiceProvider.ts

@@ -0,0 +1,40 @@
+import type {
+  ServiceInfo,
+  ServiceProvider,
+} from "../../api/service/ServiceProvider.ts";
+import DefaultTreePrinterService from "./DefaultTreePrinterService.ts";
+import { TREE_PRINTER_SERVICE_ID } from "../../api/service/core/TreePrinterService.ts";
+import type Context from "../../api/Context.ts";
+import type PrinterService from "../../api/service/core/PrinterService.ts";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.ts";
+import type CLIConfig from "../../api/CLIConfig.ts";
+
+export default class TreePrinterServiceProvider implements ServiceProvider {
+  readonly serviceId: string = TREE_PRINTER_SERVICE_ID;
+  readonly #defaultTreePrinterService: DefaultTreePrinterService;
+
+  public constructor(
+    readonly servicePriority: number,
+  ) {
+    this.#defaultTreePrinterService = new DefaultTreePrinterService();
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    return Promise.resolve({
+      service: this.#defaultTreePrinterService,
+      commands: [],
+    });
+  }
+
+  initService(context: Context): Promise<void> {
+    const printerService = context.getServiceById(
+      PRINTER_SERVICE_ID,
+    ) as PrinterService;
+
+    this.#defaultTreePrinterService.colorEnabled = printerService.colorEnabled;
+    this.#defaultTreePrinterService.colorFunction = printerService.color
+      .bind(printerService);
+
+    return Promise.resolve(undefined);
+  }
+}

package/src/terminal/Ansi.ts

@@ -0,0 +1,27 @@
+const CSI = "\x1b[";
+const OSC = "\x1b]";
+const BEL = "\x07";
+const SEP = ";";
+
+export const CLEAR_LINE = CSI + "2K";
+export const CURSOR_LEFT = CSI + "G";
+export const CURSOR_UP = CSI + "1A";
+export const HIDE_CURSOR = CSI + "?25l";
+export const SHOW_CURSOR = CSI + "?25h";
+export const ITALIC_START = CSI + "3m";
+export const ITALIC_END = CSI + "23m";
+export const FOREGROUND_COLOR_END = CSI + "39m";
+export const BACKGROUND_COLOR_END = CSI + "49m";
+export const HYPERLINK_END = `${OSC}8${SEP}${SEP}${BEL}`;
+
+export function foregroundColorStart(r: number, g: number, b: number): string {
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+export function backgroundColorStart(r: number, g: number, b: number): string {
+  return `\x1b[48;2;${r};${g};${b}m`;
+}
+
+export function hyperlinkStart(url: string): string {
+  return `${OSC}8${SEP}${SEP}${url}${BEL}`;
+}