termark 1.0.0

package/LICENCE.txt

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,240 @@
+# ![Termark](https://static.q-file.com/projects/termark/termark.svg)
+
+Termark is a basic library to format console output to the standard non-browser terminal.
+
+## Features & Highlights
+
+- 0-dependency
+- [ESM & CJS compatible](#esm--cjs-compatibility)
+- [NO_COLOR](https://no-color.org/)-friendly
+- [Basic ANSI styling](#basic-ansi-styling) (`dim`, `bold`, `italic`, …)
+- [4-bit](#4-bit-colours) ($2^4 = 16$) colours (`red`, `cyan`, `blueBright`, …)
+- [8-bit](#8-bit-colours) ($2^8 = 256$) colours (`ansi256()`)
+- [24-bit](#24-bit-colours) ($2^{24} = 16777216$; `truecolor`) colours (`rgb()`)
+- [Gradients](#gradients) (`gradient()`)
+- Built-in [terminal logging methods](#built-in-terminal-logging-methods) (`success()`, `info()`, `warn()`, `error()`)
+- [Template strings](#template-strings) & [nested styles](#nested-styles) (``` green`Success: File ${cyan`plans.txt`} created successfully!` ```)
+- [Colour-detection utilities](#colour-detection-utilities) (`areColorsEnabled`, `is8bitEnabled`, `is24bitEnabled`)
+
+## Installation
+
+```bash
+npm install termark
+```
+
+## ESM & CJS compatibility
+
+Termark is compatible with both ECMAScript modules (`import`/`export` syntax), and CommonJS:
+
+```js
+// CJS:
+const termark = require('termark');
+
+// ESM:
+import termark from 'termark';
+```
+
+## Usage
+
+Here's a quick reference for every feature Termark provides:
+
+```ts
+import termark from 'termark';
+
+console.log(
+    termark.red('This is red text.'),
+    termark.bgGreen('This text has a green background.'),
+    termark.cyan`There's support for template strings as well`,
+    termark.ansi256('text', 33)('This single function handles text and background colour!'),
+    termark.rgb('background', 42, 122, 255)('This is some dark blue text'),
+    termark.gradient('text', [[53, 72, 172], [200, 230, 121]])('Gradients are also possible.'),
+    termark.areColorsEnabled,
+    termark.is8bitEnabled,
+    termark.is24bitEnabled
+);
+```
+
+### Basic ANSI styling
+
+```ts
+import termark from 'termark';
+
+termark.reset('...');
+termark.bold('...');
+termark.dim('...');
+termark.italic('...');
+termark.underline('...');
+termark.blink('...');
+termark.inverse('...');
+termark.overline('...');
+termark.hidden('...');
+termark.strike('...');
+```
+
+### 4-bit colours
+
+```ts
+import termark from 'termark';
+
+termark.black('...');
+termark.red('...');
+termark.green('...');
+termark.yellow('...');
+termark.blue('...');
+termark.magenta('...');
+termark.white('...');
+
+termark.blackBright('...');
+termark.redBright('...');
+termark.greenBright('...');
+termark.yellowBright('...');
+termark.blueBright('...');
+termark.magentaBright('...');
+termark.whiteBright('...');
+
+termark.bgBlack('...');
+termark.bgRed('...');
+termark.bgGreen('...');
+termark.bgYellow('...');
+termark.bgBlue('...');
+termark.bgMagenta('...');
+termark.bgWhite('...');
+
+termark.bgBlackBright('...');
+termark.bgRedBright('...');
+termark.bgGreenBright('...');
+termark.bgYellowBright('...');
+termark.bgBlueBright('...');
+termark.bgMagentaBright('...');
+termark.bgWhiteBright('...');
+```
+
+### 8-bit colours
+
+```ts
+import termark from 'termark';
+
+termark.ansi256('text', 33)('...');
+termark.ansi256('background', 200)('...');
+```
+
+### 24-bit colours
+
+```ts
+import termark from 'termark';
+
+// You can specify your RGB values as an array:
+termark.rgb('text', [182, 22, 234])('...');
+termark.rgb('background', [200, 0, 184])('...');
+
+// ...or as a simple list of three values:
+termark.rgb('text', 182, 22, 234)('...');
+termark.rgb('background', 200, 0, 184)('...');
+
+
+// This method is compatible with `color-convert`:
+import convert from 'color-convert';
+
+termark.rgb('text', convert.hex.rgb('008330'))('...');
+```
+
+### Gradients
+
+```ts
+import termark from 'termark';
+
+termark.gradient('text', [[200, 123, 0], [0, 255, 255], [177, 209, 10]])('...');
+termark.gradient('background', [[123, 75, 204], [255, 255, 255], [0, 44, 55]])('...');
+```
+
+The way this works is as follows:
+
+We have two colours $C_1 = (R_1,G_1,B_1)$ and $C_2 = (R_2,G_2,B_2)$, 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 $C_i$.  
+For that, we can do the following:
+
+$$
+\begin{align*}
+t   &= \frac{i}{L-1} \\\\
+R_i &= R_1 + t \times (R_2 - R_1) \\
+G_i &= G_1 + t \times (G_2 - G_1) \\
+B_i &= B_1 + t \times (B_2 - B_1)
+\end{align*}
+$$
+
+We then apply $C_i$ to each character $i$ to get our (mostly) smooth gradient.
+
+**Please note that gradients do not support nested styling.**
+
+### Built-in terminal logging methods
+
+```ts
+import termark from 'termark';
+
+termark.success('...'); // Logs some message in green as an info message.
+termark.info('...'); // Logs some message in blue as an info message.
+termark.warning('...'); // Logs some message in yellow as a warning.
+termark.error('...'); // Logs some message in red as an error.
+
+// These also support prefixes for branding purposes:
+
+const brandPrefix = termark.blue('Example') + termark.blackBright(' - ');
+
+termark.error('File not found', brandPrefix);
+```
+
+### Template strings
+
+```ts
+import termark from 'termark';
+
+// Instead of using this:
+termark.blue('...');
+
+// ...you can use this:
+termark.blue`...`;
+```
+
+### Nested styles
+
+```ts
+import termark from 'termark';
+
+termark.blue(
+    'This is some blue text ' +
+    termark.yellow('That becomes yellow,') +
+    ' that becomes blue again.'
+);
+```
+
+### Colour-detection utilities
+
+```ts
+import termark from 'termark';
+
+termark.areColorsEnabled; // Check whether terminal colours are enabled.
+termark.is8bitEnabled; // Check whether 8-bit (256) colours are enabled.
+termark.is24bitEnabled; // Check whether 24-bit (truecolor) colours are enabled.
+```
+
+## Licence
+
+Termark's code is licenced under the [Apache licence version 2](https://www.apache.org/licenses/LICENSE-2.0).  
+The full licence text is present in these source files.
+In addition, this snippet of text is present at the top of all files:
+
+```txt
+Copyright 2025 Q
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```

package/dist/index.cjs

@@ -0,0 +1,181 @@
+/*
+Copyright 2025 Q
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+'use strict';
+
+const areColoursEnabled = () => {
+    const noColour = process.env.NO_COLOR;
+    return noColour ? false : true;
+};
+const getColourSupport = () => {
+    const colourTerm = process.env.COLORTERM;
+    const is16bit = colourTerm ? (colourTerm.includes('ansi') && !(colourTerm.includes('256'))) : false;
+    const is256 = colourTerm ? colourTerm.includes('ansi256') : false;
+    const isTrueColor = colourTerm ? (colourTerm.includes('truecolor') || colourTerm.includes('24bit')) : false;
+    return {
+        is16bit,
+        is256,
+        isTrueColor
+    };
+};
+function format(open, close, type) {
+    if (type === 'color' && !areColoursEnabled())
+        return (input) => input.toString();
+    const opener = `\x1b[${open}m`;
+    const closer = `\x1b[${close}m`;
+    return (input$1) => {
+        const input = input$1.toString().trim();
+        const index = input.indexOf(closer);
+        if (index === -1)
+            return `${opener}${input}${closer}`;
+        return `${opener}${input.replaceAll(closer, closer + opener)}${closer}`;
+    };
+}
+function interpolate(color1, color2, factor) {
+    return [
+        Math.round(color1[0] + factor * (color2[0] - color1[0])),
+        Math.round(color1[1] + factor * (color2[1] - color1[1])),
+        Math.round(color1[2] + factor * (color2[2] - color1[2])),
+    ];
+}
+
+const termark = {
+    areColorsEnabled: areColoursEnabled(),
+    is8bitEnabled: getColourSupport().is256,
+    is24bitEnabled: getColourSupport().isTrueColor,
+    reset: format(0, 0, 'format'),
+    bold: format(1, 22, 'format'),
+    dim: format(2, 22, 'format'),
+    italic: format(3, 23, 'format'),
+    underline: format(4, 24, 'format'),
+    blink: format(5, 25, 'format'),
+    inverse: format(7, 27, 'format'),
+    overline: format(53, 55, 'format'),
+    hidden: format(8, 28, 'format'),
+    strike: format(9, 29, 'format'),
+    black: format(30, 39, 'color'),
+    red: format(31, 39, 'color'),
+    green: format(32, 39, 'color'),
+    yellow: format(33, 39, 'color'),
+    blue: format(34, 39, 'color'),
+    magenta: format(35, 39, 'color'),
+    cyan: format(36, 39, 'color'),
+    white: format(37, 39, 'color'),
+    blackBright: format(90, 39, 'color'),
+    redBright: format(91, 39, 'color'),
+    greenBright: format(92, 39, 'color'),
+    yellowBright: format(93, 39, 'color'),
+    blueBright: format(94, 39, 'color'),
+    magentaBright: format(95, 39, 'color'),
+    cyanBright: format(96, 39, 'color'),
+    whiteBright: format(97, 39, 'color'),
+    bgBlack: format(40, 49, 'color'),
+    bgRed: format(41, 49, 'color'),
+    bgGreen: format(42, 49, 'color'),
+    bgYellow: format(43, 49, 'color'),
+    bgBlue: format(44, 49, 'color'),
+    bgMagenta: format(45, 49, 'color'),
+    bgCyan: format(46, 49, 'color'),
+    bgWhite: format(47, 49, 'color'),
+    bgBlackBright: format(100, 49, 'color'),
+    bgRedBright: format(101, 49, 'color'),
+    bgGreenBright: format(102, 49, 'color'),
+    bgYellowBright: format(103, 49, 'color'),
+    bgBlueBright: format(104, 49, 'color'),
+    bgMagentaBright: format(105, 49, 'color'),
+    bgCyanBright: format(106, 49, 'color'),
+    bgWhiteBright: format(107, 49, 'color'),
+    ansi256(type, color) {
+        if (color < 0 || color > 255)
+            throw new Error(termark.red('Value `color` is out of range! The value must be a number between 0 and 255!'));
+        if (!getColourSupport().is256 || !areColoursEnabled())
+            return (input) => input.toString();
+        const textFormat = `38;5;${color}`;
+        const bgFormat = `48;5;${color}`;
+        const opener = type === 'text' ? textFormat : bgFormat;
+        const closer = type === 'text' ? 39 : 49;
+        return format(opener, closer, 'color');
+    },
+    rgb(type, ...rgb) {
+        let red;
+        let green;
+        let blue;
+        if (Array.isArray(rgb[0])) {
+            red = rgb[0][0];
+            green = rgb[0][1];
+            blue = rgb[0][2];
+        }
+        else {
+            red = rgb[0];
+            green = rgb[1];
+            blue = rgb[2];
+        }
+        if (((typeof red === 'number') && (red < 0 || red > 255)) ||
+            ((typeof green === 'number') && (green < 0 || green > 255)) ||
+            ((typeof blue === 'number') && (blue < 0 || blue > 255)))
+            throw new Error(termark.red('One or multiple of the colours specified is out of range! Each colour can have a value only between 0 and 255!'));
+        if (!getColourSupport().isTrueColor)
+            return (input) => input.toString();
+        const textFormat = `38;2;${red};${green};${blue}`;
+        const bgFormat = `48;2;${red};${green};${blue}`;
+        const opener = type === 'text' ? textFormat : bgFormat;
+        const closer = type === 'text' ? 39 : 49;
+        return format(opener, closer, 'color');
+    },
+    gradient(type, colors) {
+        if (!areColoursEnabled() || !getColourSupport().isTrueColor)
+            return (input) => input.toString();
+        const textFormat = `38;2;`;
+        const bgFormat = `48;2;`;
+        const opener = type === 'text' ? `\x1b[${textFormat}` : `\x1b[${bgFormat}`;
+        const closer = type === 'text' ? `\x1b[${39}m` : `\x1b[${49}m`;
+        return (input$1) => {
+            const input = input$1.toString().trim();
+            const colourCount = colors.length;
+            const step = Math.min(input.length / (colourCount - 1));
+            let result = '';
+            for (let character = 0; character < input.length; character++) {
+                const colourIndex = Math.min(Math.floor(character / step), colourCount - 2);
+                const factor = (character % step) / step;
+                const startColour = colors[colourIndex];
+                const endColour = colors[colourIndex + 1];
+                const interpolatedColour = interpolate(startColour, endColour, factor);
+                result += `${opener}${interpolatedColour[0]};${interpolatedColour[1]};${interpolatedColour[2]}m${input[character]}${closer}`;
+            }
+            return result;
+        };
+    },
+    success(message, prefix = '') {
+        console.info(`${prefix}${termark.green(message)}`);
+    },
+    info(message, prefix = '') {
+        console.info(`${prefix}${termark.blue(message)}`);
+    },
+    warn(message, prefix = '') {
+        console.warn(`${prefix}${termark.yellow(message)}`);
+    },
+    error(message, prefix = '') {
+        console.error(`${prefix}${termark.red(message)}`);
+    },
+    custom(opener, closer, type) {
+        const formatType = type === 'asColor' ? 'color' : 'format';
+        return format(opener, closer, formatType);
+    },
+};
+
+module.exports = termark;
+
+// Copyright (C) 2025 Q

package/dist/index.d.ts

@@ -0,0 +1,514 @@
+/**
+ * All properties and methods provided by Termark.
+ */
+interface Termark {
+    /**
+     * Check whether terminal colours are enabled.
+     *
+     * @returns true If terminal colours are enabled.
+     */
+    areColorsEnabled: boolean;
+    /**
+     * Check whether 8-bit colours are enabled.
+     *
+     * @returns true If 8-bit colours are enabled.
+     */
+    is8bitEnabled: boolean;
+    /**
+     * Check whether 24-bit colours (truecolor) are enabled.
+     *
+     * @returns true If 24-bit colours are enabled.
+     */
+    is24bitEnabled: boolean;
+    /**
+     * Reset all formatting of some text.
+     *
+     * @param input The text to format.
+     * @returns The formatted text.
+     */
+    reset: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bold.
+     *
+     * @param input The text to format.
+     * @returns The text in bold letters.
+     */
+    bold: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text thinner.
+     *
+     * @param input The text to format.
+     * @returns The text in thinner letters.
+     */
+    dim: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text italic. May not be widely supported.
+     *
+     * @param input The text to format.
+     * @returns The text with italicized (usually slanted) letters.
+     */
+    italic: (input: string | TemplateStringsArray) => string;
+    /**
+     * Underline some text.
+     *
+     * @param input The text to format.
+     * @returns The underlined text.
+     */
+    underline: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text blink slowly.
+     *
+     * @param input The text to format.
+     * @returns The blinking text.
+     */
+    blink: (input: string | TemplateStringsArray) => string;
+    /**
+     * Invert some text (foreground colour becomes background colour, background colour becomes foreground colour).
+     *
+     * @param input The text to format.
+     * @returns The inverted text.
+     */
+    inverse: (input: string | TemplateStringsArray) => string;
+    /**
+     * Add a line above some text (may not be widely supported).
+     *
+     * @param input The text to format.
+     * @returns The text with a line above it.
+     */
+    overline: (input: string | TemplateStringsArray) => string;
+    /**
+     * Hide some text (may not be widely supported).
+     *
+     * @param input The text to format.
+     * @returns The hidden text.
+     */
+    hidden: (input: string | TemplateStringsArray) => string;
+    /**
+     * Add a line through (strike) some text.
+     *
+     * @param input The text to format.
+     * @returns The striked text.
+     */
+    strike: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text black.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured black.
+     */
+    black: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text red.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured red.
+     */
+    red: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text green.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured green.
+     */
+    green: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text yellow.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured yellow.
+     */
+    yellow: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text blue.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured blue.
+     */
+    blue: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text magenta.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured magenta.
+     */
+    magenta: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text cyan.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured cyan.
+     */
+    cyan: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text white.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured white.
+     */
+    white: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright black (grey).
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright black (grey).
+     */
+    blackBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright red.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright red.
+     */
+    redBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright green.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright green.
+     */
+    greenBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright yellow.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright yellow.
+     */
+    yellowBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright blue.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright blue.
+     */
+    blueBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright magenta.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright magenta.
+     */
+    magentaBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright cyran.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright cyan.
+     */
+    cyanBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make some text bright white.
+     *
+     * @param input The text to colour.
+     * @returns If colours are enabled, `input` coloured bright white.
+     */
+    whiteBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text black.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a black background.
+     */
+    bgBlack: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text red.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a red background.
+     */
+    bgRed: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text green.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a green background.
+     */
+    bgGreen: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text yellow.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a yellow background.
+     */
+    bgYellow: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text blue.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a blue background.
+     */
+    bgBlue: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text magenta.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a magenta background.
+     */
+    bgMagenta: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text cyan.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a cyan background.
+     */
+    bgCyan: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text white.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a white background.
+     */
+    bgWhite: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright black (grey).
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a bright black (grey) background.
+     */
+    bgBlackBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright red.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a bright re backgroundd.
+     */
+    bgRedBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright green.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a bright gree backgroundn.
+     */
+    bgGreenBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright yellow.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a bright yello backgroundw.
+     */
+    bgYellowBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright blue.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a bright blu backgrounde.
+     */
+    bgBlueBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright magenta.
+     *
+     * @param input The text whose background to colour.
+     * @returns If colours are enabled, `input` with a bright magent backgrounda.
+     */
+    bgMagentaBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright cyan.
+     *
+     * @param input The desired text to be styled.
+     * @returns If colours are enabled, `input` with a bright cyan background.
+     */
+    bgCyanBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * Make the background of some text bright white.
+     *
+     * @param input The desired text to be styled.
+     * @returns If colours are enabled, `input` with a bright white background.
+     */
+    bgWhiteBright: (input: string | TemplateStringsArray) => string;
+    /**
+     * 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: 'text' | 'background', color: number) => (input: string | TemplateStringsArray) => string;
+    /**
+     * 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: 'text' | 'background', ...rgb: [number, number, number] | [[number, number, number]]) => (input: string | TemplateStringsArray) => string;
+    /**
+     * 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: 'text' | 'background', colors: [number, number, number][]) => (input: string | TemplateStringsArray) => string;
+    /**
+     * 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, 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, 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, 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, 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: number | string, closer: number | string, type: 'asFormat' | 'asColor') => (input: string | TemplateStringsArray) => string;
+}
+/**
+ * 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` object are static, 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
+ * 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
+ * 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;

package/dist/index.mjs

@@ -0,0 +1,179 @@
+/*
+Copyright 2025 Q
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const areColoursEnabled = () => {
+    const noColour = process.env.NO_COLOR;
+    return noColour ? false : true;
+};
+const getColourSupport = () => {
+    const colourTerm = process.env.COLORTERM;
+    const is16bit = colourTerm ? (colourTerm.includes('ansi') && !(colourTerm.includes('256'))) : false;
+    const is256 = colourTerm ? colourTerm.includes('ansi256') : false;
+    const isTrueColor = colourTerm ? (colourTerm.includes('truecolor') || colourTerm.includes('24bit')) : false;
+    return {
+        is16bit,
+        is256,
+        isTrueColor
+    };
+};
+function format(open, close, type) {
+    if (type === 'color' && !areColoursEnabled())
+        return (input) => input.toString();
+    const opener = `\x1b[${open}m`;
+    const closer = `\x1b[${close}m`;
+    return (input$1) => {
+        const input = input$1.toString().trim();
+        const index = input.indexOf(closer);
+        if (index === -1)
+            return `${opener}${input}${closer}`;
+        return `${opener}${input.replaceAll(closer, closer + opener)}${closer}`;
+    };
+}
+function interpolate(color1, color2, factor) {
+    return [
+        Math.round(color1[0] + factor * (color2[0] - color1[0])),
+        Math.round(color1[1] + factor * (color2[1] - color1[1])),
+        Math.round(color1[2] + factor * (color2[2] - color1[2])),
+    ];
+}
+
+const termark = {
+    areColorsEnabled: areColoursEnabled(),
+    is8bitEnabled: getColourSupport().is256,
+    is24bitEnabled: getColourSupport().isTrueColor,
+    reset: format(0, 0, 'format'),
+    bold: format(1, 22, 'format'),
+    dim: format(2, 22, 'format'),
+    italic: format(3, 23, 'format'),
+    underline: format(4, 24, 'format'),
+    blink: format(5, 25, 'format'),
+    inverse: format(7, 27, 'format'),
+    overline: format(53, 55, 'format'),
+    hidden: format(8, 28, 'format'),
+    strike: format(9, 29, 'format'),
+    black: format(30, 39, 'color'),
+    red: format(31, 39, 'color'),
+    green: format(32, 39, 'color'),
+    yellow: format(33, 39, 'color'),
+    blue: format(34, 39, 'color'),
+    magenta: format(35, 39, 'color'),
+    cyan: format(36, 39, 'color'),
+    white: format(37, 39, 'color'),
+    blackBright: format(90, 39, 'color'),
+    redBright: format(91, 39, 'color'),
+    greenBright: format(92, 39, 'color'),
+    yellowBright: format(93, 39, 'color'),
+    blueBright: format(94, 39, 'color'),
+    magentaBright: format(95, 39, 'color'),
+    cyanBright: format(96, 39, 'color'),
+    whiteBright: format(97, 39, 'color'),
+    bgBlack: format(40, 49, 'color'),
+    bgRed: format(41, 49, 'color'),
+    bgGreen: format(42, 49, 'color'),
+    bgYellow: format(43, 49, 'color'),
+    bgBlue: format(44, 49, 'color'),
+    bgMagenta: format(45, 49, 'color'),
+    bgCyan: format(46, 49, 'color'),
+    bgWhite: format(47, 49, 'color'),
+    bgBlackBright: format(100, 49, 'color'),
+    bgRedBright: format(101, 49, 'color'),
+    bgGreenBright: format(102, 49, 'color'),
+    bgYellowBright: format(103, 49, 'color'),
+    bgBlueBright: format(104, 49, 'color'),
+    bgMagentaBright: format(105, 49, 'color'),
+    bgCyanBright: format(106, 49, 'color'),
+    bgWhiteBright: format(107, 49, 'color'),
+    ansi256(type, color) {
+        if (color < 0 || color > 255)
+            throw new Error(termark.red('Value `color` is out of range! The value must be a number between 0 and 255!'));
+        if (!getColourSupport().is256 || !areColoursEnabled())
+            return (input) => input.toString();
+        const textFormat = `38;5;${color}`;
+        const bgFormat = `48;5;${color}`;
+        const opener = type === 'text' ? textFormat : bgFormat;
+        const closer = type === 'text' ? 39 : 49;
+        return format(opener, closer, 'color');
+    },
+    rgb(type, ...rgb) {
+        let red;
+        let green;
+        let blue;
+        if (Array.isArray(rgb[0])) {
+            red = rgb[0][0];
+            green = rgb[0][1];
+            blue = rgb[0][2];
+        }
+        else {
+            red = rgb[0];
+            green = rgb[1];
+            blue = rgb[2];
+        }
+        if (((typeof red === 'number') && (red < 0 || red > 255)) ||
+            ((typeof green === 'number') && (green < 0 || green > 255)) ||
+            ((typeof blue === 'number') && (blue < 0 || blue > 255)))
+            throw new Error(termark.red('One or multiple of the colours specified is out of range! Each colour can have a value only between 0 and 255!'));
+        if (!getColourSupport().isTrueColor)
+            return (input) => input.toString();
+        const textFormat = `38;2;${red};${green};${blue}`;
+        const bgFormat = `48;2;${red};${green};${blue}`;
+        const opener = type === 'text' ? textFormat : bgFormat;
+        const closer = type === 'text' ? 39 : 49;
+        return format(opener, closer, 'color');
+    },
+    gradient(type, colors) {
+        if (!areColoursEnabled() || !getColourSupport().isTrueColor)
+            return (input) => input.toString();
+        const textFormat = `38;2;`;
+        const bgFormat = `48;2;`;
+        const opener = type === 'text' ? `\x1b[${textFormat}` : `\x1b[${bgFormat}`;
+        const closer = type === 'text' ? `\x1b[${39}m` : `\x1b[${49}m`;
+        return (input$1) => {
+            const input = input$1.toString().trim();
+            const colourCount = colors.length;
+            const step = Math.min(input.length / (colourCount - 1));
+            let result = '';
+            for (let character = 0; character < input.length; character++) {
+                const colourIndex = Math.min(Math.floor(character / step), colourCount - 2);
+                const factor = (character % step) / step;
+                const startColour = colors[colourIndex];
+                const endColour = colors[colourIndex + 1];
+                const interpolatedColour = interpolate(startColour, endColour, factor);
+                result += `${opener}${interpolatedColour[0]};${interpolatedColour[1]};${interpolatedColour[2]}m${input[character]}${closer}`;
+            }
+            return result;
+        };
+    },
+    success(message, prefix = '') {
+        console.info(`${prefix}${termark.green(message)}`);
+    },
+    info(message, prefix = '') {
+        console.info(`${prefix}${termark.blue(message)}`);
+    },
+    warn(message, prefix = '') {
+        console.warn(`${prefix}${termark.yellow(message)}`);
+    },
+    error(message, prefix = '') {
+        console.error(`${prefix}${termark.red(message)}`);
+    },
+    custom(opener, closer, type) {
+        const formatType = type === 'asColor' ? 'color' : 'format';
+        return format(opener, closer, formatType);
+    },
+};
+
+export { termark as default };
+
+// Copyright (C) 2025 Q

package/dist/util.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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: [number, number, number], color2: [number, number, number], factor: number): [number, number, number];

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "termark",
+    "version": "1.0.0",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.mjs",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "scripts": {
+        "build": "rollup -c",
+        "test": "node dist/index.mjs"
+    },
+    "keywords": [
+        "utility",
+        "console",
+        "node",
+        "output",
+        "formatting"
+    ],
+    "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",
+    "repository": {
+        "type": "git",
+        "url": "https://codeberg.org/Genesis_Software/termark.git"
+    },
+    "devDependencies": {
+        "@types/node": "^24.3.0",
+        "rollup": "^4.49.0",
+        "rollup-plugin-cleanup": "^3.2.1",
+        "rollup-plugin-typescript2": "^0.36.0",
+        "typescript": "^5.9.2"
+    }
+}