termark 2.1.0 → 3.0.0

package/dist/utilities.d.mts

@@ -0,0 +1,54 @@
+import { ColourLevel } from "./types.mjs";
+
+//#region src/utilities.d.ts
+/**
+* Check whether colours are supported in a given terminal environment.
+*
+* Use {@linkcode hasNoColour} for checking whether terminals that *could* support colour don't do so.
+*/
+declare function areColoursSupported(): boolean;
+/**
+* Check whether a terminal environment supports at least some level of colours.
+*
+* @param level A colour level.
+*/
+declare function supports(level: ColourLevel): boolean;
+/**
+* Check whether a terminal environment supports at most a given colour level.
+*
+* @param level A colour level.
+*/
+declare function supportsAtMost(level: ColourLevel): boolean;
+/**
+* Modify the plain text part of a string with ANSI escape sequences.
+*
+* @example Creating a `toUpperCase` method for ANSI strings
+* ```ts
+* import { transformPreserveAnsi } from "termark";
+*
+* const toUpperCase = transformPreserveAnsi((str) => str.toUpperCase());
+* ```
+*
+* @param fn A function that transforms some string.
+*/
+declare function transformPreserveAnsi(fn: (plain: string) => string): (str: string) => string;
+/**
+* Make some string upper-case while preserving ANSI escape sequences as-is.
+*
+* @str The string to transform.
+*/
+declare const ansiUpperCase: (str: string) => string;
+/**
+* Make some string lower-case while preserving ANSI escape sequences as-is.
+*
+* @param str The string to transform.
+*/
+declare const ansiLowerCase: (str: string) => string;
+/**
+* Remove ANSI escape sequences from some text.
+*
+* @param input The input to strip of ANSI escape sequences.
+*/
+declare function stripAnsi(input: string): string;
+//#endregion
+export { ansiLowerCase, ansiUpperCase, areColoursSupported, stripAnsi, supports, supportsAtMost, transformPreserveAnsi };

package/dist/utilities.mjs

@@ -0,0 +1 @@
+import{getColourLevel as e}from"./__internal/env.mjs";function t(){return e()!==0}function n(t){return e()>=t}function r(t){return e()<=t}function i(e){return t=>{let n=/(\u{001B}\[[0-9;]*[A-PRZ])|(.+?)/giu,r=``;for(let i of t.matchAll(n)){let t=i[0];r+=t.charCodeAt(0)===27?t:e(t)}return r}}const a=i(e=>e.toUpperCase()),o=i(e=>e.toLowerCase());function s(e){return e.replace(/\u{001B}\[[0-9;]*m/gu,``)}export{o as ansiLowerCase,a as ansiUpperCase,t as areColoursSupported,s as stripAnsi,n as supports,r as supportsAtMost,i as transformPreserveAnsi};

package/package.json

@@ -1,39 +1,51 @@
 {
   "name": "termark",
-  "version": "2.1.0",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    }
-  },
+  "version": "3.0.0",
+  "description": "A basic library to format console output to the standard non-browser terminal.",
   "keywords": [
-    "utility",
     "console",
+    "formatting",
     "node",
     "output",
-    "formatting"
+    "utility"
   ],
-  "author": "Miyazaki \"Q\" Hashimoto",
-  "license": "Apache-2.0",
-  "description": "A basic library to format console output to the standard non-browser terminal.",
   "homepage": "https://genesis.q-file.com/projects/termark",
+  "license": "Apache-2.0",
+  "author": "Miyazaki \"Q\" Hashimoto",
   "repository": {
     "type": "git",
     "url": "https://codeberg.org/Genesis_Software/termark.git"
   },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
   "devDependencies": {
-    "@rollup/plugin-terser": "^0.4.4",
     "@types/node": "^24.3.0",
-    "rollup": "^4.49.0",
-    "rollup-plugin-typescript2": "^0.36.0",
-    "typescript": "^5.9.2"
+    "oxfmt": "^0.50.0",
+    "oxlint": "^1.65.0",
+    "tsdown": "^0.22.0",
+    "tsx": "^4.22.0",
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.6"
   },
+  "readme": "README.npm.md",
   "scripts": {
-    "build": "rollup -c",
-    "test": "node dist/index.mjs"
+    "build": "tsdown --config .config/tsdown.config.ts",
+    "format": "oxfmt --config .config/oxfmt.config.ts",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "test": "vitest --config .config/vitest.config.ts",
+    "demo:truecolor": "tsx examples/truecolor.ts",
+    "demo:box": "tsx examples/box.ts",
+    "demo:basic": "tsx examples/basic.ts",
+    "demo:link": "tsx examples/link.ts"
   }
 }

package/dist/index.d.ts

@@ -1,383 +0,0 @@
-import { ANSIStyleType, RGB, FormatFunction, LoggerOptions, LogObject } from './util';
-/**
- * The `Termark` class is almost the same as the {@linkcode termark} object and by using `Termark.init`, it effectively does become the same.
- *
- * However, it is nonetheless useful as it enables type-safety,
- *
- * You use this class the same way as you would the {@linkcode termark} object.
- *
- * @example
- * ```typescript
- * import { Termark } from 'termark';
- *
- * const termark = new Termark(); // This is the same as if you'd import the `termark` object.
- * termark.success('Termark is working!');
- *
- * // Alternatively, you could do:
- * Termark.init.success('This works, too!');
- * ```
- *
- * @see The {@linkcode termark} object.
- */
-export declare class Termark {
-    /**
-     * A reference to a Termark instance.
-     *
-     * This is an object that holds the properties defined below.
-     */
-    private static termarkInstance;
-    /**
-     * A static getter function that returns a Termark reference object.
-     *
-     * With this method, it's possible to use the `Termark` class like an object.
-     *
-     * @example
-     * ```typescript
-     * import { Termark } from 'termark';
-     * Termark.init.success('...');
-     *
-     * // ...is the same as:
-     *
-     * import termark from 'termark';
-     * termark.success('...');
-     * ```
-    */
-    static get init(): Termark;
-    private static successPrefix;
-    private static infoPrefix;
-    private static warnPrefix;
-    private static errorPrefix;
-    /** Check whether terminal colours are enabled. */
-    areColorsEnabled: boolean;
-    /** Check whether 8-bit colours are enabled. */
-    is8bitEnabled: boolean;
-    /** Check whether 24-bit colours are enabled. */
-    is24bitEnabled: boolean;
-    /** Reset all styles. */
-    reset: FormatFunction;
-    /** Make some text bold. */
-    bold: FormatFunction;
-    /** Make some text thin. */
-    dim: FormatFunction;
-    /** Make some text italic. May not be widely supported. */
-    italic: FormatFunction;
-    /** Underline some text. */
-    underline: FormatFunction;
-    /** Make some text blink slowly. May not be widely supported/may not work everywhere. */
-    blink: FormatFunction;
-    /** Invert some text (foreground colour becomes background colour, background colour becomes foreground colour). */
-    inverse: FormatFunction;
-    /** Add a line above some text. May not be widely supported. */
-    overline: FormatFunction;
-    /** Visually hide some text. */
-    hidden: FormatFunction;
-    /** Add a line through (strike) some text. */
-    strike: FormatFunction;
-    /** Colour some text black. */
-    black: FormatFunction;
-    /** Colour some text red. */
-    red: FormatFunction;
-    /** Colour some text green. */
-    green: FormatFunction;
-    /** Colour some text yellow. */
-    yellow: FormatFunction;
-    /** Colour some text blue. */
-    blue: FormatFunction;
-    /** Colour some text magenta. */
-    magenta: FormatFunction;
-    /** Colour some text cyan. */
-    cyan: FormatFunction;
-    /** Colour some text white. */
-    white: FormatFunction;
-    /** Colour some text bright black (grey). */
-    blackBright: FormatFunction;
-    /** Colour some text bright red. */
-    redBright: FormatFunction;
-    /** Colour some text bright green. */
-    greenBright: FormatFunction;
-    /** Colour some text bright yellow. */
-    yellowBright: FormatFunction;
-    /** Colour some text bright blue. */
-    blueBright: FormatFunction;
-    /** Colour some text bright magenta. */
-    magentaBright: FormatFunction;
-    /** Colour some text bright cyan. */
-    cyanBright: FormatFunction;
-    /** Colour some text bright white. */
-    whiteBright: FormatFunction;
-    /** Colour the background of some text black. */
-    bgBlack: FormatFunction;
-    /** Colour the background of some text red. */
-    bgRed: FormatFunction;
-    /** Colour the background of some text green. */
-    bgGreen: FormatFunction;
-    /** Colour the background of some text yellow. */
-    bgYellow: FormatFunction;
-    /** Colour the background of some text blue. */
-    bgBlue: FormatFunction;
-    /** Colour the background of some text magenta. */
-    bgMagenta: FormatFunction;
-    /** Colour the background of some text cyan. */
-    bgCyan: FormatFunction;
-    /** Colour the background of some text white. */
-    bgWhite: FormatFunction;
-    /** Colour the background of some text bright black (grey). */
-    bgBlackBright: FormatFunction;
-    /** Colour the background of some text bright red. */
-    bgRedBright: FormatFunction;
-    /** Colour the background of some text bright green. */
-    bgGreenBright: FormatFunction;
-    /** Colour the background of some text bright yellow. */
-    bgYellowBright: FormatFunction;
-    /** Colour the background of some text bright blue. */
-    bgBlueBright: FormatFunction;
-    /** Colour the background of some text bright magenta. */
-    bgMagentaBright: FormatFunction;
-    /** Colour the background of some text bright cyan. */
-    bgCyanBright: FormatFunction;
-    /** Colour the background of some text bright white. */
-    bgWhiteBright: FormatFunction;
-    /**
-     * Make some text or its background one of 256 colours.
-     * If `color` is bigger than 255 or smaller than 0, it automatically rounds to 255 or 0 respectively.
-     *
-     * @param type Whether the styling should be applied to the text itself or the background.
-     * @param color A number between 0 and 255 that specifies the colour.
-     * @param content The string that should be styled.
-     * @returns If terminal colours are enabled and [8-bit colours](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) are supported, the stylized text. If either is false, it returns the plain string.
-     * @see https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
-     */
-    ansi256(type: ANSIStyleType, color: number): FormatFunction;
-    /**
-     * Make some text or its background using custom RGB values.
-     *
-     * @param type Whether to apply the colour to the text itself or its background.
-     * @param rgb A list of `red`, `green`, and `blue` values.
-     * @returns A function to specify an input, which returns the stylized text, assuming colours are enabled, *and* `truecolor` is enabled as well.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.rgb('background', 128, 84, 249)('...');
-     * termark.rgb('text', [85, 222, 124])('...');
-     * ```
-     */
-    rgb(type: ANSIStyleType, ...rgb: RGB | [RGB]): FormatFunction;
-    /**
-     * Apply a gradient to some text or its background.
-     *
-     * @param type Whether to apply the gradient to the text itself or its background.
-     * @param colors An array of RGB values
-     * @returns A function to specify an input, which returns the stylized input, assuming colours are enabled, *and* `truecolor` is enabled as well.
-     * @see https://htmlcolorcodes.com/ For colour conversions.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.gradient('text', [[53, 72, 172], [200, 230, 121]])('...');
-     * termark.gradient('background', [[222, 111, 0], [93, 255, 68], [0, 224, 110]])('...');
-     * ```
-     */
-    gradient(type: ANSIStyleType, colors: RGB[]): FormatFunction;
-    /**
-     * Logs a `message` to the console on the `info` level.
-     *
-     * **Note:** Since there is no dedicated '`success`' method, we have to print to the same level
-     * as `info()`.
-     *
-     * @param message The message to be logged in green as a success (info).
-     * @param prefix An optional brand prefix.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.success('...'); // Logs "..." in green as a success (info).
-     * ```
-     */
-    success(message: string | TemplateStringsArray, prefix?: string): void;
-    /**
-     * Logs a `message` to the console on the `info` level.
-     *
-     * @param message The message to be logged in blue as an info.
-     * @param prefix An optional brand prefix.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.info('...'); // Logs "..." in blue as an info.
-     * ```
-     */
-    info(message: string | TemplateStringsArray, prefix?: string): void;
-    /**
-     * Logs a `message` to the console on the `error` level.
-     *
-     * **Note:** In Node, `console.warn` and `console.error` print to the *same* level (`error`),
-     * and are therefore interchangeable. As such, this method only exists to provide a different look
-     * for an error message (e.g., for non-fatal errors).
-     *
-     * @param message The message to be logged in yellow as a warning (error).
-     * @param prefix An optional brand prefix.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.warn('...'); // Logs "..." in yellow as a warning (error).
-     * ```
-     */
-    warn(message: string | TemplateStringsArray, prefix?: string): void;
-    /**
-     * Logs a `message` to the console on the `error` level.
-     *
-     * @param message The message to be logged in red as an error.
-     * @param prefix An optional brand prefix.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.error('...'); // Logs "..." in red as an error.
-     * ```
-     */
-    error(message: string | TemplateStringsArray, prefix?: string): void;
-    /**
-     * Style some text using entirely custom settings.
-     *
-     * Please not that this method will not return any errors by itself.
-     * As such, it's advised that you're familiar with [the ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code) if you plan to use this method.
-     * However, this method will still return the plain text if the styling you want to apply doesn't exist.
-     *
-     * Also note that you **mustn't include the actual escape sequence (e.g., `\x1b[`), nor the symbol at the end of the code (e.g., `m`)**, only the parameters themselves.
-     *
-     * @param opener The code that should be prepended to the text. This is for styling your input itself.
-     * @param closer The code that should be appended to the text. This is for styling what comes after your input. It's best if this is either `0`, or the code to set the default style of something (e.g., `39` to reset to the default text colour).
-     * @param type Whether the formatting should be viewed as applying colour, or performing simple styling. If it is the former, styling won't be applied if terminal colours are disabled.
-     * @returns The text stylized using `opener`.
-     *
-     * @example
-     * ```typescript
-     * import termark from 'termark';
-     *
-     * termark.custom('58;2;33', 59)('...'); // This should result in a string with a blue underline.
-     * ```
-     */
-    custom(opener: string | number, closer: string | number, type: 'asColor' | 'asFormat'): FormatFunction;
-    /**
-     * Create a theme (multiple stylings grouped together).
-     *
-     * This creates a function you can call to style some desired string using the stylings
-     * you specified.
-     *
-     * @example
-     * ```ts
-     * import termark, { Termark } from 'termark';
-     *
-     * const myTheme = Termark.createTheme(
-     *      termark.bold,
-     *      termark.blue,
-     *      termark.bgGreen
-     * );
-     *
-     * console.log(
-     *      myTheme('...') // message will be bold with a green background and blue text
-     * );
-     * ```
-     *
-     * @param styles Stylings to apply.
-     * @returns A function to style some desired text using the specified styles.
-     */
-    static createTheme(...styles: FormatFunction[]): FormatFunction;
-    /**
-     * Define a custom logger.
-     *
-     * Using the `options` object, you can specify the styling that is applied to each method. For example, you can customize
-     * how a message logged using `error()` looks.
-     *
-     * For `success()`, `info()`, `warn()`, and `error()`, you can also customize the prefix.
-     *
-     * The resulting methods are exactly like the predefined ones, apart from the custom styling. That means that each method also
-     * takes an optional `prefix` argument for branding purposes.
-     *
-     * @param options An object to customize the logger.
-     * @returns An object with methods to log various messages to the terminal with various (semantic) styling.
-     */
-    static createLogger(options: LoggerOptions): LogObject;
-}
-/**
- * The `termark` object enables accessing all features of Termark:
- *
- * - Properties (retrieve information)
- * - Methods (commands)
- *
- * For info regarding ANSI styling:
- * @see https://en.wikipedia.org/wiki/ANSI_escape_code
- *
- * ---
- *
- * With properties, you're able to use features of Termark that don't execute
- * any command per se, but simply to retrieve information; you don't perform
- * any operation with these.
- *
- * @example
- * ```typescript
- * import termark from 'termark';
- *
- * // All properties provided by Termark:
- *
- * termark.areColorsEnabled; // Check whether colours are enabled
- * termark.is8bitEnabled; // Check whether 8-bit (256) colours are enabled
- * termark.is24bitEnabled; // Check whether 24-bit (truecolor) colours are enabled
- * ```
- *
- * In addition, properties on the `Termark` class are static-ish, i.e., they only do one thing, and you have no input on it.
- *
- * ---
- *
- * With methods on the other hand, you *do* perform commands and operations.
- * Methods are dynamic, meaning that you *do* specify how they work.
- *
- * @example
- * ```typescript
- * import termark from 'termark';
- *
- * termark.red('...'); // Returns "..." in red.
- * termark.rgb('background', [255, 255, 255])('...'); // Returns "..." with a white background.
- * ```
- *
- * With all methods, you **must** append either `('...')` or ``` `...` ```, and replace "`...`"
- * with a string of your choosing. This is made possible by the fact that most of (see below) Termark's
- * methods return a function where you specify your input.
- *
- * @example
- * ```typescript
- * import termark from 'termark';
- *
- * termark.ansi256('text', 33)('This is blue text');
- * termark.ansi256('text', 33)`This is also blue text`;
- * ```
- *
- * ### Exceptions
- *
- * There are some exceptions to the above, however; not *all* of Termark's methods return
- * a function to specify your input. These ones are:
- *
- * ```typescript
- * import termark from 'termark';
- *
- * termark.success('...');
- * termark.info('...');
- * termark.warn('...');
- * termark.error('...');
- * ```
- *
- * This is because the above three methods handle console outputs for you. Therefore, they needn't
- * return a function where you specify your input.
- */
-declare const termark: Termark;
-export default termark;
-export declare const areColorsEnabled: boolean, is8bitEnabled: boolean, is24bitEnabled: boolean, reset: FormatFunction, bold: FormatFunction, dim: FormatFunction, italic: FormatFunction, underline: FormatFunction, blink: FormatFunction, inverse: FormatFunction, overline: FormatFunction, hidden: FormatFunction, strike: FormatFunction, black: FormatFunction, red: FormatFunction, green: FormatFunction, yellow: FormatFunction, blue: FormatFunction, magenta: FormatFunction, cyan: FormatFunction, white: FormatFunction, blackBright: FormatFunction, redBright: FormatFunction, greenBright: FormatFunction, yellowBright: FormatFunction, blueBright: FormatFunction, magentaBright: FormatFunction, cyanBright: FormatFunction, whiteBright: FormatFunction, bgBlack: FormatFunction, bgRed: FormatFunction, bgGreen: FormatFunction, bgYellow: FormatFunction, bgBlue: FormatFunction, bgMagenta: FormatFunction, bgCyan: FormatFunction, bgWhite: FormatFunction, bgBlackBright: FormatFunction, bgRedBright: FormatFunction, bgGreenBright: FormatFunction, bgYellowBright: FormatFunction, bgBlueBright: FormatFunction, bgMagentaBright: FormatFunction, bgCyanBright: FormatFunction, bgWhiteBright: FormatFunction, ansi256: (type: ANSIStyleType, color: number) => FormatFunction, rgb: (type: ANSIStyleType, ...rgb: RGB | [RGB]) => FormatFunction, gradient: (type: ANSIStyleType, colors: RGB[]) => FormatFunction, success: (message: string | TemplateStringsArray, prefix?: string) => void, info: (message: string | TemplateStringsArray, prefix?: string) => void, warn: (message: string | TemplateStringsArray, prefix?: string) => void, error: (message: string | TemplateStringsArray, prefix?: string) => void, custom: (opener: string | number, closer: string | number, type: "asColor" | "asFormat") => FormatFunction;
-export declare const createTheme: typeof Termark.createTheme, createLogger: typeof Termark.createLogger;

package/dist/util.d.ts

@@ -1,157 +0,0 @@
-export type ANSIStyleType = 'text' | 'background';
-export type RGB = [number, number, number];
-/**
- * Check whether terminal colours are supported/enabled.
- *
- * @returns If the `NO_COLOR` environment variable is undefined, true. If it has any value, it returns false, as per the [specifications](https://no-color.org/).
- */
-export declare const areColoursEnabled: () => boolean;
-/**
- * Check whether a colour level is supported.
- *
- * @returns A property that is used to check the colour level support.
- */
-export declare const getColourSupport: () => {
-    is16bit: boolean;
-    is256: boolean;
-    isTrueColor: boolean;
-};
-/**
- * Format some text using ANSI codes.
- *
- * @param open The code prepended to the text. This is used to style the text itself.
- * @param close The code appended to the text. This is used to style what comes immediately after the text, and should ideally be a reset code.
- * @param type Whether the styling applies basic formatting, or colours the text.
- * @returns If terminal colours are enabled and `type` is set to `'color'`, some coloured text. If `type` is set to `'format'`, the formatted text.
- */
-export declare function format(open: number | string, close: number | string, type: 'format' | 'color'): (input: string | TemplateStringsArray) => string;
-/**
- * Calculate an intermediate colour between two colours.
- *
- * This is done as follows:
- * We have two colours: `C1 = (R1,G1,B1)`, and `C2 = (R2,G2,B2)`, and we need to generate a gradient over a string of length `L`.
- * For each character at index `i` (from 0 to `L-1`), we need to find an interpolated colour `Ci`.
- *
- * For that, we can do the following:
- * ```txt
- * t = i/(L-1)
- *
- * Ri = R1 + t * (R2 - R1)
- * Gi = G1 + t * (G2 - G1)
- * Bi = B1 + t * (B2 - B1)
- * ```
- *
- * We then apply `Ci` to each character `i` to get our (mostly) smooth gradient.
- *
- * @param color1 The starting colour.
- * @param color2 The ending colour.
- * @param factor How to calculate the colour.
- * @returns An RGB value that is the colour between `color1` and `color2` at `factor`.
- */
-export declare function interpolate(color1: RGB, color2: RGB, factor: number): RGB;
-/**
- * From [`JSAux`](https://codeberg.org/Genesis_Software/js-aux).
- */
-export declare function clamp(value: number, min: number, max: number): number;
-export type FormatFunctionReturn = string | TemplateStringsArray;
-export type FormatFunction = (input: FormatFunctionReturn) => string;
-/**
- * The object returned by the `createLogger()` method of the `Termark` class.
- */
-export type LogObject = {
-    /**
-     * A generic logging function.
-     *
-     * @param message Th message string.
-     * @param prefix An optional prefix for branding purposes.
-     */
-    log(message: string, prefix?: string): void;
-    /**
-     * A success logging function. Prints to the same level as `log()`.
-     *
-     * @param message Th message string.
-     * @param prefix An optional prefix for branding purposes.
-     */
-    success(message: string, prefix?: string): void;
-    /**
-     * An info logging function. Prints to the same level as `log()`.
-     *
-     * @param message Th message string.
-     * @param prefix An optional prefix for branding purposes.
-     */
-    info(message: string, prefix?: string): void;
-    /**
-     * A warning logging function. Prints to the same level as `error()`.
-     *
-     * @param message Th message string.
-     * @param prefix An optional prefix for branding purposes.
-     */
-    warn(message: string, prefix?: string): void;
-    /**
-     * An error logging function.
-     *
-     * @param message Th message string.
-     * @param prefix An optional prefix for branding purposes.
-     */
-    error(message: string, prefix?: string): void;
-};
-/**
- * Options for the logging methods that aren't `log()` of a custom logger.
- */
-export interface LoggerLogOptions {
-    /**
-     * Customize the prefix of a certain "level" or "type" of log (e.g., `error`).
-     *
-     * This is only for semantics.
-     *
-     * If left empty, the default prefix is used. If set to `false`, it will be omitted.
-     *
-     * The following are the default prefixes:
-     *
-     * - `success()`: `[✔]`
-     * - `info()`: `[i]`,
-     * - `warn()`: `[!]`,
-     * - `error()`: `[X]`
-     */
-    prefix: string | false;
-    /**
-     * An array of styles to apply.
-     *
-     * @example [termark.blue, termark.bold]
-     */
-    styles: FormatFunction[];
-}
-/**
- * Options to customize a custom logger.
- */
-export interface LoggerOptions {
-    /**
-     * The default styling.
-     *
-     * This is what gets applied to the message string when the `log()` method is called.
-     */
-    default: FormatFunction[];
-    /**
-     * Styling to apply when the `success()` method is called.
-     *
-     * Keep in mind that this is only for visuals; there is no "success" log level
-     * in Node. Therefore, this prints to the same level as `log()` and `info()`.
-     */
-    success?: LoggerLogOptions;
-    /**
-     * Styling to apply when the `info()` method is called.
-     *
-     * This prints to the same level as `log()` and `success()`.
-     */
-    info?: LoggerLogOptions;
-    /**
-     * Styling to apply when the `warn()` method is called.
-     *
-     * This prints to the same level as `error()`.
-     */
-    warn?: LoggerLogOptions;
-    /**
-     * Styling to apply when the `error()` method is called.`
-     */
-    error?: LoggerLogOptions;
-}