@flowscripter/dynamic-cli-framework 1.1.5 → 1.2.0

package/src/service/dataDumpGenerator/DefaultDataDumpGeneratorService.ts

@@ -0,0 +1,80 @@
+import { Buffer } from "node:buffer";
+import type DataDumpGeneratorService from "../../api/service/core/DataDumpGeneratorService.ts";
+import {
+  type ByteRangeColor,
+  DumpFormat,
+  type HexDumpGenerateOptions,
+} from "../../api/service/core/DataDumpGeneratorService.ts";
+
+export default class DefaultDataDumpGeneratorService
+  implements DataDumpGeneratorService {
+  colorEnabled = true;
+  colorFunction: (text: string, hexFormattedColor: string) => string = (text) =>
+    text;
+
+  #colorByte(
+    text: string,
+    byteValue: number,
+    colorScheme?: ByteRangeColor[],
+  ): string {
+    if (!this.colorEnabled || !colorScheme) {
+      return text;
+    }
+    for (const range of colorScheme) {
+      if (byteValue >= range.start && byteValue <= range.end) {
+        return this.colorFunction(text, range.color);
+      }
+    }
+    return text;
+  }
+
+  generate(data: Buffer, options?: HexDumpGenerateOptions): string {
+    if (data.length === 0) {
+      return "";
+    }
+
+    const format = options?.format ?? DumpFormat.HEX;
+    const bytesPerGroup = options?.bytesPerGroup ?? 4;
+    const groupsPerRow = options?.groupsPerRow ?? 8;
+    const spacesBetweenGroups = options?.spacesBetweenGroups ?? 1;
+    const colorScheme = options?.colorScheme;
+
+    const bytesPerRow = bytesPerGroup * groupsPerRow;
+    const groupSeparator = " ".repeat(spacesBetweenGroups);
+    const rows: string[] = [];
+
+    for (let offset = 0; offset < data.length; offset += bytesPerRow) {
+      const groups: string[] = [];
+
+      for (let g = 0; g < groupsPerRow; g++) {
+        const groupStart = offset + g * bytesPerGroup;
+        let groupStr = "";
+
+        for (let b = 0; b < bytesPerGroup; b++) {
+          const byteIndex = groupStart + b;
+          if (byteIndex < data.length) {
+            const byteValue = data[byteIndex]!;
+            let rendered: string;
+            if (format === DumpFormat.ASCII) {
+              rendered = byteValue >= 0x20 && byteValue <= 0x7e
+                ? String.fromCharCode(byteValue)
+                : ".";
+            } else {
+              rendered = byteValue.toString(16).toUpperCase().padStart(2, "0");
+            }
+            groupStr += this.#colorByte(rendered, byteValue, colorScheme);
+          } else {
+            // Pad partial group
+            groupStr += format === DumpFormat.ASCII ? " " : "  ";
+          }
+        }
+
+        groups.push(groupStr);
+      }
+
+      rows.push(groups.join(groupSeparator));
+    }
+
+    return rows.join("\n");
+  }
+}

package/src/service/imagePrinter/DefaultImagePrinterService.ts

@@ -0,0 +1,23 @@
+import ImageRenderer from "../../terminal/ImageRenderer.ts";
+import type ImagePrinterService from "../../api/service/core/ImagePrinterService.ts";
+import type Terminal from "../../terminal/Terminal.ts";
+
+export default class DefaultImagePrinterService implements ImagePrinterService {
+  readonly #renderer: ImageRenderer;
+
+  constructor(terminal: Terminal) {
+    this.#renderer = new ImageRenderer(terminal);
+  }
+
+  image(
+    imageBuffer: Uint8Array,
+    widthPercentage: number = 100,
+    hexFormattedBackgroundColor?: string,
+  ): Promise<string> {
+    return this.#renderer.renderImage(
+      imageBuffer,
+      widthPercentage,
+      hexFormattedBackgroundColor,
+    );
+  }
+}

package/src/service/imagePrinter/ImagePrinterServiceProvider.ts

@@ -0,0 +1,32 @@
+import type {
+  ServiceInfo,
+  ServiceProvider,
+} from "../../api/service/ServiceProvider.ts";
+import DefaultImagePrinterService from "./DefaultImagePrinterService.ts";
+import { IMAGE_PRINTER_SERVICE_ID } from "../../api/service/core/ImagePrinterService.ts";
+import type Context from "../../api/Context.ts";
+import type CLIConfig from "../../api/CLIConfig.ts";
+import type Terminal from "../../terminal/Terminal.ts";
+
+export default class ImagePrinterServiceProvider implements ServiceProvider {
+  readonly serviceId: string = IMAGE_PRINTER_SERVICE_ID;
+  readonly #defaultImagePrinterService: DefaultImagePrinterService;
+
+  public constructor(
+    readonly servicePriority: number,
+    terminal: Terminal,
+  ) {
+    this.#defaultImagePrinterService = new DefaultImagePrinterService(terminal);
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    return Promise.resolve({
+      service: this.#defaultImagePrinterService,
+      commands: [],
+    });
+  }
+
+  initService(_context: Context): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+}

package/src/service/prettyPrinter/PrettyPrinterServiceProvider.ts

@@ -27,7 +27,7 @@ export default class PrettyPrinterServiceProvider implements ServiceProvider {
     this.#defaultPrettyPrinterService = new DefaultPrettyPrinterService();
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.#defaultPrettyPrinterService,
       commands: [],

package/src/service/printer/DefaultPrinterService.ts

@@ -1,17 +1,22 @@
 import { default as Spinner } from "./terminal/Spinner.ts";
 import { default as Progress } from "./terminal/Progress.ts";
 import type PrinterService from "../../api/service/core/PrinterService.ts";
-import { type Icon, Level } from "../../api/service/core/PrinterService.ts";
-import Terminal from "./terminal/Terminal.ts";
+import {
+  type Icon,
+  Level,
+  type ProgressStyle,
+  type SpinnerStyle,
+} from "../../api/service/core/PrinterService.ts";
+import type Terminal from "../../terminal/Terminal.ts";
 import { Color } from "./terminal/Color.ts";
 import { getDarkModeTheme, getLightModeTheme } from "./terminal/Theme.ts";
 import { WritableStream } from "node:stream/web";
-import Styler from "./terminal/Styler.ts";
-
+import type Styler from "../../terminal/Styler.ts";
 export default class DefaultPrinterService implements PrinterService {
   readonly stdoutWritable: WritableStream;
   readonly stderrWritable: WritableStream;
   #stdoutIsColor: boolean;
+  #stdoutTerminal: Terminal;
   #stderrTerminal: Terminal;
   #styler: Styler;
   #isDarkMode = true;
@@ -46,12 +51,14 @@ export default class DefaultPrinterService implements PrinterService {
     stderrWritableStream: WritableStream,
     stdoutIsColor: boolean,
     stderrIsColor: boolean,
+    stdoutTerminal: Terminal,
     stderrTerminal: Terminal,
     styler: Styler,
   ) {
     this.stdoutWritable = stdoutWritableStream;
     this.stderrWritable = stderrWritableStream;
     this.#stdoutIsColor = stdoutIsColor;
+    this.#stdoutTerminal = stdoutTerminal;
     this.#stderrTerminal = stderrTerminal;
     this.#styler = styler;
     this.#styler.colorEnabled = stderrIsColor;
@@ -90,6 +97,26 @@ export default class DefaultPrinterService implements PrinterService {
     return this.#styler.colorEnabled;
   }
 
+  set hyperlinksEnabled(enabled: boolean) {
+    this.#styler.hyperlinksEnabled = enabled;
+  }
+
+  get hyperlinksEnabled(): boolean {
+    return this.#styler.hyperlinksEnabled;
+  }
+
+  public hyperlink(text: string, url: string): string {
+    return this.#styler.hyperlink(text, url);
+  }
+
+  public stdoutColumns(): number {
+    return this.#stdoutTerminal.columns();
+  }
+
+  public stderrColumns(): number {
+    return this.#stderrTerminal.columns();
+  }
+
   set darkMode(isDarkMode: boolean) {
     this.#isDarkMode = isDarkMode;
     if (isDarkMode) {
@@ -97,12 +124,12 @@ export default class DefaultPrinterService implements PrinterService {
     } else {
       this.#theme = getLightModeTheme();
     }
-    this.#spinner.spinnerColor = this.#theme[Color.EMPHASISED];
-    this.#spinner.messageColor = this.#theme[Color.PRIMARY];
-    this.#progress.completeColor = this.#theme[Color.GREEN];
-    this.#progress.remainingColor = this.#theme[Color.SECONDARY];
-    this.#progress.labelColor = this.#theme[Color.SECONDARY];
-    this.#progress.valueColor = this.#theme[Color.PRIMARY];
+    this.#spinner.spinnerColor = this.#theme[Color.EMPHASISED]!;
+    this.#spinner.messageColor = this.#theme[Color.PRIMARY]!;
+    this.#progress.completeColor = this.#theme[Color.GREEN]!;
+    this.#progress.remainingColor = this.#theme[Color.SECONDARY]!;
+    this.#progress.labelColor = this.#theme[Color.SECONDARY]!;
+    this.#progress.valueColor = this.#theme[Color.PRIMARY]!;
   }
 
   get darkMode(): boolean {
@@ -110,19 +137,19 @@ export default class DefaultPrinterService implements PrinterService {
   }
 
   public primary(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.PRIMARY]);
+    return this.#styler.colorText(message, this.#theme[Color.PRIMARY]!);
   }
 
   public secondary(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.SECONDARY]);
+    return this.#styler.colorText(message, this.#theme[Color.SECONDARY]!);
   }
 
   public emphasised(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.EMPHASISED]);
+    return this.#styler.colorText(message, this.#theme[Color.EMPHASISED]!);
   }
 
   public selected(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.SELECTED]);
+    return this.#styler.colorText(message, this.#theme[Color.SELECTED]!);
   }
 
   public italic(message: string): string {
@@ -130,52 +157,135 @@ export default class DefaultPrinterService implements PrinterService {
   }
 
   public yellow(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.YELLOW]);
+    return this.#styler.colorText(message, this.#theme[Color.YELLOW]!);
   }
 
   public orange(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.ORANGE]);
+    return this.#styler.colorText(message, this.#theme[Color.ORANGE]!);
   }
 
   public red(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.RED]);
+    return this.#styler.colorText(message, this.#theme[Color.RED]!);
   }
 
   public magenta(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.MAGENTA]);
+    return this.#styler.colorText(message, this.#theme[Color.MAGENTA]!);
   }
 
   public violet(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.VIOLET]);
+    return this.#styler.colorText(message, this.#theme[Color.VIOLET]!);
   }
 
   public blue(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.BLUE]);
+    return this.#styler.colorText(message, this.#theme[Color.BLUE]!);
   }
 
   public cyan(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.CYAN]);
+    return this.#styler.colorText(message, this.#theme[Color.CYAN]!);
   }
 
   public green(message: string): string {
-    return this.#styler.colorText(message, this.#theme[Color.GREEN]);
+    return this.#styler.colorText(message, this.#theme[Color.GREEN]!);
   }
 
-  public color(message: string, hexFormattedColor: string): string {
+  #parseHexColor(hexFormattedColor: string): number {
     if (
       (hexFormattedColor.length !== 7) ||
       (!hexFormattedColor.toLowerCase().startsWith("#"))
     ) {
       throw new Error(`Invalid color: ${hexFormattedColor}`);
     }
-
     const colorValue = parseInt(hexFormattedColor.slice(1), 16);
-
     if (isNaN(colorValue) || (colorValue < 0 || colorValue > 0xffffff)) {
       throw new Error(`Invalid color: ${hexFormattedColor}`);
     }
+    return colorValue;
+  }
+
+  public color(message: string, hexFormattedColor: string): string {
+    return this.#styler.colorText(
+      message,
+      this.#parseHexColor(hexFormattedColor),
+    );
+  }
+
+  public backgroundPrimary(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.PRIMARY]!,
+    );
+  }
+
+  public backgroundSecondary(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.SECONDARY]!,
+    );
+  }
+
+  public backgroundEmphasised(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.EMPHASISED]!,
+    );
+  }
 
-    return this.#styler.colorText(message, colorValue);
+  public backgroundSelected(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.SELECTED]!,
+    );
+  }
+
+  public backgroundYellow(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.YELLOW]!,
+    );
+  }
+
+  public backgroundOrange(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.ORANGE]!,
+    );
+  }
+
+  public backgroundRed(message: string): string {
+    return this.#styler.backgroundColorText(message, this.#theme[Color.RED]!);
+  }
+
+  public backgroundMagenta(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.MAGENTA]!,
+    );
+  }
+
+  public backgroundViolet(message: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#theme[Color.VIOLET]!,
+    );
+  }
+
+  public backgroundBlue(message: string): string {
+    return this.#styler.backgroundColorText(message, this.#theme[Color.BLUE]!);
+  }
+
+  public backgroundCyan(message: string): string {
+    return this.#styler.backgroundColorText(message, this.#theme[Color.CYAN]!);
+  }
+
+  public backgroundGreen(message: string): string {
+    return this.#styler.backgroundColorText(message, this.#theme[Color.GREEN]!);
+  }
+
+  public backgroundColor(message: string, hexFormattedColor: string): string {
+    return this.#styler.backgroundColorText(
+      message,
+      this.#parseHexColor(hexFormattedColor),
+    );
   }
 
   public async debug(message: string, icon?: Icon): Promise<void> {
@@ -226,11 +336,17 @@ export default class DefaultPrinterService implements PrinterService {
     return this.#threshold;
   }
 
-  public async showSpinner(message?: string): Promise<void> {
+  public async showSpinner(
+    message?: string,
+    style?: SpinnerStyle,
+  ): Promise<void> {
     await this.#progress.hideAll();
     if (this.#threshold > Level.INFO) {
       return;
     }
+    if (style != null) {
+      this.#spinner.spinnerStyle = style;
+    }
     await this.#spinner.show(message);
   }
 
@@ -243,11 +359,15 @@ export default class DefaultPrinterService implements PrinterService {
     message = "",
     total = 100,
     current = 0,
+    style?: ProgressStyle,
   ): Promise<number> {
     await this.#spinner.hide();
     if (this.#threshold > Level.INFO) {
       return -1;
     }
+    if (style != null) {
+      this.#progress.progressStyle = style;
+    }
 
     return this.#progress.add(units, message, total, current);
   }

package/src/service/printer/PrinterServiceProvider.ts

@@ -4,15 +4,14 @@ import type {
   ServiceInfo,
   ServiceProvider,
 } from "../../api/service/ServiceProvider.ts";
-import PrinterService, {
-  PRINTER_SERVICE_ID,
-} from "../../api/service/core/PrinterService.ts";
+import type PrinterService from "../../api/service/core/PrinterService.ts";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.ts";
 import DarkModeCommand from "./command/DarkModeCommand.ts";
 import NoColorCommand from "./command/NoColorCommand.ts";
+import NoHyperlinksCommand from "./command/NoHyperlinksCommand.ts";
 import type CLIConfig from "../../api/CLIConfig.ts";
-import ShutdownService, {
-  SHUTDOWN_SERVICE_ID,
-} from "../../api/service/core/ShutdownService.ts";
+import type ShutdownService from "../../api/service/core/ShutdownService.ts";
+import { SHUTDOWN_SERVICE_ID } from "../../api/service/core/ShutdownService.ts";
 
 /**
  * Provides a {@link PrinterService}.
@@ -36,10 +35,11 @@ export default class PrinterServiceProvider implements ServiceProvider {
     this.printerService = printerService;
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.printerService,
       commands: [
+        new NoHyperlinksCommand(this, this.servicePriority + 3),
         new DarkModeCommand(this, this.servicePriority + 2),
         new NoColorCommand(this, this.servicePriority + 1),
         new LogLevelCommand(this, this.servicePriority),

package/src/service/printer/command/LogLevelCommand.ts

@@ -23,6 +23,7 @@ export default class LogLevelCommand implements GlobalModifierCommand {
       "WARN",
       "ERROR",
     ],
+    isCaseInsensitive: true,
     defaultValue: "INFO",
     configurationKey: "LOG_LEVEL",
   };
@@ -44,7 +45,7 @@ export default class LogLevelCommand implements GlobalModifierCommand {
   ): Promise<void> {
     const logLevel = argumentValue as string;
 
-    switch (logLevel) {
+    switch (logLevel.toUpperCase()) {
       case "DEBUG":
         this.#printerServiceProvider.printerService!.setLevel(
           Level.DEBUG,

package/src/service/printer/command/NoHyperlinksCommand.ts

@@ -0,0 +1,40 @@
+import type GlobalModifierCommand from "../../../api/command/GlobalModifierCommand.ts";
+import type GlobalCommandArgument from "../../../api/argument/GlobalCommandArgument.ts";
+import {
+  type ArgumentSingleValueType,
+  ArgumentValueTypeName,
+} from "../../../api/argument/ArgumentValueTypes.ts";
+import type Context from "../../../api/Context.ts";
+import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+
+export default class NoHyperlinksCommand implements GlobalModifierCommand {
+  readonly name = "no-hyperlinks";
+  readonly description = "Disable hyperlinks for output";
+  readonly enableConfiguration = true;
+  readonly argument: GlobalCommandArgument = {
+    type: ArgumentValueTypeName.BOOLEAN,
+    defaultValue: false,
+    configurationKey: "NO_HYPERLINKS",
+  };
+  readonly executePriority: number;
+
+  readonly #printerServiceProvider: PrinterServiceProvider;
+
+  public constructor(
+    printerServiceProvider: PrinterServiceProvider,
+    executePriority: number,
+  ) {
+    this.#printerServiceProvider = printerServiceProvider;
+    this.executePriority = executePriority;
+  }
+
+  public execute(
+    _context: Context,
+    argumentValue: ArgumentSingleValueType,
+  ): Promise<void> {
+    this.#printerServiceProvider.printerService!.hyperlinksEnabled =
+      !argumentValue as boolean;
+
+    return Promise.resolve();
+  }
+}

package/src/service/printer/terminal/Progress.ts

@@ -1,8 +1,19 @@
-import Styler from "./Styler.ts";
-import type Terminal from "./Terminal.ts";
+import type Styler from "../../../terminal/Styler.ts";
+import type Terminal from "../../../terminal/Terminal.ts";
 
 const RATE_SMOOTHING_FACTOR = 0.005;
 
+export { ProgressStyle } from "../../../api/service/core/PrinterService.ts";
+import { ProgressStyle } from "../../../api/service/core/PrinterService.ts";
+
+const STYLE_CHARS: Record<
+  ProgressStyle,
+  { complete: string; remaining: string }
+> = {
+  [ProgressStyle.STROKE]: { complete: "=", remaining: "-" },
+  [ProgressStyle.FILL]: { complete: "▰", remaining: "▱" },
+};
+
 interface Bar {
   name: string;
   current: number;
@@ -26,6 +37,7 @@ export default class Progress {
   #remColor = 0x585858;
   #labColor = 0x585858;
   #valColor = 0x808080;
+  #style: ProgressStyle = ProgressStyle.STROKE;
 
   public constructor(terminal: Terminal, styler: Styler) {
     this.#terminal = terminal;
@@ -282,12 +294,13 @@ export default class Progress {
       const completeLength = Math.floor(
         totalLength * barInfo.bar.current / barInfo.bar.total,
       );
+      const chars = STYLE_CHARS[this.#style];
       const complete = this.#styler.colorText(
-        "=".repeat(completeLength),
+        chars.complete.repeat(completeLength),
         this.#comColor,
       );
       const remaining = this.#styler.colorText(
-        "-".repeat(totalLength - completeLength),
+        chars.remaining.repeat(totalLength - completeLength),
         this.#remColor,
       );
 
@@ -331,6 +344,10 @@ export default class Progress {
     this.#valColor = color;
   }
 
+  set progressStyle(style: ProgressStyle) {
+    this.#style = style;
+  }
+
   #formatTime(millis: number): string {
     let sec = millis / 1000;
     if (sec < 60) {

package/src/service/printer/terminal/Spinner.ts

@@ -1,7 +1,7 @@
-import Styler from "./Styler.ts";
-import type Terminal from "./Terminal.ts";
+import type Styler from "../../../terminal/Styler.ts";
+import type Terminal from "../../../terminal/Terminal.ts";
 
-const FRAMES = [
+const BOX_FRAMES = [
   "⠋",
   "⠙",
   "⠹",
@@ -14,6 +14,20 @@ const FRAMES = [
   "⠏",
 ];
 
+const STAR_FRAMES = [
+  "★",
+  "✶",
+  "✷",
+  "✹",
+  "✷",
+  "✶",
+  "★",
+  "✦",
+];
+
+export { SpinnerStyle } from "../../../api/service/core/PrinterService.ts";
+import { SpinnerStyle } from "../../../api/service/core/PrinterService.ts";
+
 export default class Spinner {
   #isShown = false;
   #message: string | undefined;
@@ -21,6 +35,7 @@ export default class Spinner {
   #timer: Timer | undefined;
   #spinColor = 0x8a8a8a;
   #msgColor = 0x808080;
+  #style: SpinnerStyle = SpinnerStyle.BOX;
   readonly #terminal: Terminal;
   readonly #styler: Styler;
 
@@ -29,23 +44,28 @@ export default class Spinner {
     this.#styler = styler;
   }
 
+  get #frames(): string[] {
+    return this.#style === SpinnerStyle.STAR ? STAR_FRAMES : BOX_FRAMES;
+  }
+
   async #nextFrame(): Promise<void> {
     if (!this.#isShown) {
       return;
     }
+    const frames = this.#frames;
     await this.#terminal.clearLine();
     if (this.#message) {
       await this.#terminal.write(
-        `${this.#styler.colorText(FRAMES[this.#frameIndex], this.#spinColor)} ${
-          this.#styler.colorText(this.#message!, this.#msgColor)
-        }`,
+        `${
+          this.#styler.colorText(frames[this.#frameIndex]!, this.#spinColor)
+        } ${this.#styler.colorText(this.#message!, this.#msgColor)}`,
       );
     } else {
       await this.#terminal.write(
-        this.#styler.colorText(FRAMES[this.#frameIndex], this.#spinColor),
+        this.#styler.colorText(frames[this.#frameIndex]!, this.#spinColor),
       );
     }
-    this.#frameIndex = (this.#frameIndex + 1) % FRAMES.length;
+    this.#frameIndex = (this.#frameIndex + 1) % frames.length;
   }
 
   public async show(message?: string): Promise<void> {
@@ -97,4 +117,8 @@ export default class Spinner {
   set messageColor(color: number) {
     this.#msgColor = color;
   }
+
+  set spinnerStyle(style: SpinnerStyle) {
+    this.#style = style;
+  }
 }

package/src/service/printer/terminal/Theme.ts

@@ -1,4 +1,4 @@
-import { Color } from "./Color";
+import { Color } from "./Color.ts";
 
 const commonTheme: Array<number> = [];