@peteanderson/ansi 0.2.3 → 0.3.0

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-declare const _exports: {
-    caret: {
+declare const _exports: ((...args: Args) => Ansi) & {
+    fg: Channel;
+    bg: Channel;
+} & {
+    caret: ReturnType<(enabled?: boolean) => {
         up: (count?: number) => string;
         down: (count?: number) => string;
         forward: (count?: number) => string;
@@ -24,8 +27,8 @@ declare const _exports: {
             blinkingUnderline: string;
             default: string;
         };
-    };
-    erase: {
+    }>;
+    erase: ReturnType<(enabled?: boolean) => {
         line: {
             toStart: string;
             toEnd: string;
@@ -37,71 +40,18 @@ declare const _exports: {
             full: string;
             scrollback: string;
         };
-    };
-    scroll: {
+    }>;
+    scroll: ReturnType<(enabled?: boolean) => {
         up: (lines?: number) => string;
         down: (lines?: number) => string;
-    };
+    }>;
     reset: string;
-    style: {
-        bold: import("./sgr/sgr").SGR;
-        dim: import("./sgr/sgr").SGR;
-        italic: import("./sgr/sgr").SGR;
-        underline: import("./sgr/sgr").SGR;
-        inverse: import("./sgr/sgr").SGR;
-        hidden: import("./sgr/sgr").SGR;
-        strikethrough: import("./sgr/sgr").SGR;
-        doubleUnderline: import("./sgr/sgr").SGR;
-        frame: import("./sgr/sgr").SGR;
-        encircle: import("./sgr/sgr").SGR;
-        overline: import("./sgr/sgr").SGR;
-    };
-    fg: {
-        black: import("./sgr/sgr").SGR;
-        red: import("./sgr/sgr").SGR;
-        green: import("./sgr/sgr").SGR;
-        yellow: import("./sgr/sgr").SGR;
-        blue: import("./sgr/sgr").SGR;
-        magenta: import("./sgr/sgr").SGR;
-        cyan: import("./sgr/sgr").SGR;
-        white: import("./sgr/sgr").SGR;
-        brightBlack: import("./sgr/sgr").SGR;
-        brightRed: import("./sgr/sgr").SGR;
-        brightGreen: import("./sgr/sgr").SGR;
-        brightYellow: import("./sgr/sgr").SGR;
-        brightBlue: import("./sgr/sgr").SGR;
-        brightMagenta: import("./sgr/sgr").SGR;
-        brightCyan: import("./sgr/sgr").SGR;
-        brightWhite: import("./sgr/sgr").SGR;
-        default: string;
-        rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
-    };
-    bg: {
-        black: import("./sgr/sgr").SGR;
-        red: import("./sgr/sgr").SGR;
-        green: import("./sgr/sgr").SGR;
-        yellow: import("./sgr/sgr").SGR;
-        blue: import("./sgr/sgr").SGR;
-        magenta: import("./sgr/sgr").SGR;
-        cyan: import("./sgr/sgr").SGR;
-        white: import("./sgr/sgr").SGR;
-        brightBlack: import("./sgr/sgr").SGR;
-        brightRed: import("./sgr/sgr").SGR;
-        brightGreen: import("./sgr/sgr").SGR;
-        brightYellow: import("./sgr/sgr").SGR;
-        brightBlue: import("./sgr/sgr").SGR;
-        brightMagenta: import("./sgr/sgr").SGR;
-        brightCyan: import("./sgr/sgr").SGR;
-        brightWhite: import("./sgr/sgr").SGR;
-        default: string;
-        rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
-    };
+    style: ReturnType<typeof import("./sgr/style").makeStyle>;
     strip: (text: string) => string;
     visibleLength: (text: string) => number;
     sanitize: (text: string) => string;
     slice: typeof import("./slice").slice;
     simplify: typeof import("./simplify/simplify").simplify;
+    features: ReturnType<typeof import("./features/features").getFeatures>;
 };
 export = _exports;

package/dist/scroll.d.ts

@@ -1,2 +1,6 @@
-export let up: (lines?: number) => string;
-export let down: (lines?: number) => string;
+export function makeScroll(enabled?: boolean): {
+    /** @type {(lines?: number) => string} */
+    up: (lines?: number) => string;
+    /** @type {(lines?: number) => string} */
+    down: (lines?: number) => string;
+};

package/dist/scroll.js

@@ -5,4 +5,10 @@ const scroll = {
     /** @type {(lines?: number) => string} */
     down: lines => `\x1b[${lines ?? 1}T`,
 };
-module.exports = scroll;
+/** @type {typeof scroll} */
+const disabled = {
+    up: () => "",
+    down: () => "",
+};
+const makeScroll = (enabled = true) => enabled ? scroll : disabled;
+module.exports = { makeScroll };

package/dist/sgr/color/color.d.ts

@@ -0,0 +1,9 @@
+export type Code = import("../sgr").Code;
+export type ColorDepth = import("../../features/types").ColorDepth;
+export type SGR = import("../sgr").SGR;
+export type Channel = import("./types").Channel;
+/** @type {(colorDepth: ColorDepth) => {fg: Channel, bg: Channel}} */
+export const makeColor: (colorDepth: ColorDepth) => {
+    fg: Channel;
+    bg: Channel;
+};

package/dist/sgr/color/color.js

@@ -0,0 +1,76 @@
+"use strict";
+const { makeSGR } = require("../sgr");
+const { makeStyle } = require("../style");
+const { clip, rgbToX256, rgbToX16, rgbToX8, x256ToRgb } = require("./utils");
+/** @typedef {import("../sgr").Code}                     Code */
+/** @typedef {import("../../features/types").ColorDepth} ColorDepth */
+/** @typedef {import("../sgr").SGR}                      SGR */
+/** @typedef {import("./types").Channel}                 Channel */
+const fgOpen = 30, fgClose = 39;
+const bgOpen = 40, bgClose = 49;
+/** @type {(colorDepth: ColorDepth, open: number, close: number) => Channel} */
+function makeChannel(colorDepth, open, close) {
+    const sgrBase = makeSGR(colorDepth > 1);
+    const style = makeStyle(colorDepth > 1);
+    /** @type {(code: Code) => SGR} */
+    const sgr = code => sgrBase(code, close);
+    /** @type {(index: number) => SGR} */
+    const bright = colorDepth >= 4 ? index => sgr(open + 60 + index) :
+        colorDepth === 3 ?
+            open === fgOpen ?
+                index => style.bold.combine(sgr(open + index)) :
+                index => sgr(open + index) :
+            () => sgr(0);
+    /** @type {(code: number) => SGR} */
+    const x16ToX8 = open === fgOpen ?
+        code => code >= 60 ? style.bold.combine(sgr(open + code - 60)) : sgr(open + code) :
+        code => code >= 60 ? sgr(open + code - 60) : sgr(open + code);
+    return {
+        black: sgr(open + 0),
+        red: sgr(open + 1),
+        green: sgr(open + 2),
+        yellow: sgr(open + 3),
+        blue: sgr(open + 4),
+        magenta: sgr(open + 5),
+        cyan: sgr(open + 6),
+        white: sgr(open + 7),
+        brightBlack: bright(0),
+        brightRed: bright(1),
+        brightGreen: bright(2),
+        brightYellow: bright(3),
+        brightBlue: bright(4),
+        brightMagenta: bright(5),
+        brightCyan: bright(6),
+        brightWhite: bright(7),
+        rgb: colorDepth >= 24 ? (r, g, b) => sgr([open + 8, 2, ...clip(r, g, b)]) :
+            colorDepth >= 8 ? (r, g, b) => sgr([open + 8, 5, rgbToX256(...clip(r, g, b))]) :
+                colorDepth >= 4 ? (r, g, b) => sgr(open + rgbToX16(...clip(r, g, b))) :
+                    colorDepth === 3 ?
+                        open === fgOpen ?
+                            (r, g, b) => x16ToX8(rgbToX16(...clip(r, g, b))) :
+                            (r, g, b) => sgr(open + rgbToX8(...clip(r, g, b))) :
+                        () => sgr(0),
+        /** @type {(...args: [number] | [number, number, number]) => SGR} */
+        x256: colorDepth >= 8 ?
+            (...args) => sgr([open + 8, 5, args.length === 3 ? rgbToX256(...clip(...args)) : clip(args[0])]) :
+            colorDepth >= 4 ?
+                (...args) => sgr(open +
+                    rgbToX16(...(args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0]))))) :
+                colorDepth === 3 ?
+                    open === fgOpen ?
+                        (...args) => x16ToX8(args.length === 3 ?
+                            rgbToX16(...clip(...args)) :
+                            rgbToX16(...x256ToRgb(clip(args[0])))) :
+                        (...args) => sgr(open + rgbToX8(...args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])))) :
+                    () => sgr(0),
+        default: colorDepth > 1 ? `\x1b[${close}m` : "",
+    };
+}
+/** @type {Partial<Record<ColorDepth, {fg: Channel, bg: Channel}>>} */
+const cache = {};
+/** @type {(colorDepth: ColorDepth) => {fg: Channel, bg: Channel}} */
+const makeColor = (colorDepth = 4) => cache[colorDepth] ?? (cache[colorDepth] = {
+    fg: makeChannel(colorDepth, fgOpen, fgClose),
+    bg: makeChannel(colorDepth, bgOpen, bgClose),
+});
+module.exports = { makeColor };

package/dist/sgr/color/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: typeof import("./color");
+export = _exports;

package/dist/sgr/color/index.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./color");

package/dist/sgr/color/utils.d.ts

@@ -0,0 +1,27 @@
+export type Code = import("../sgr").Code;
+export function rgbToX256(r: number, g: number, b: number): number;
+export function x256ToRgb(code: number): [number, number, number];
+export function rgbToX16(r: number, g: number, b: number): number;
+export function rgbToX8(r: number, g: number, b: number): number;
+/**
+ * @overload
+ * @param   {number} x
+ * @returns {number}
+ * @overload
+ * @param   {number} r
+ * @param   {number} g
+ * @param   {number} b
+ * @returns {[number, number, number]}
+ */
+export function clip(x: number): number;
+/**
+ * @overload
+ * @param   {number} x
+ * @returns {number}
+ * @overload
+ * @param   {number} r
+ * @param   {number} g
+ * @param   {number} b
+ * @returns {[number, number, number]}
+ */
+export function clip(r: number, g: number, b: number): [number, number, number];

package/dist/sgr/color/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+/** @typedef {import("../sgr").Code} Code */
+/** @type {(r: number, g: number, b: number) => number} */
+function rgbToX256(r, g, b) {
+    if (r === g && g === b) {
+        // grayscale
+        return 232 + Math.floor(r * 24 / 256);
+    }
+    // 6x6x6 color cube
+    return (16 +
+        Math.floor(r * 6 / 256) * 36 +
+        Math.floor(g * 6 / 256) * 6 +
+        Math.floor(b * 6 / 256));
+}
+/** @type {(code: number) => [number, number, number]} */
+function x256ToRgb(code) {
+    if (code >= 232) {
+        // grayscale
+        const gray = Math.round((code - 232) * 255 / 24);
+        return [gray, gray, gray];
+    }
+    code -= 16;
+    const r = Math.floor(code / 36) * 51;
+    const g = Math.floor((code % 36) / 6) * 51;
+    const b = (code % 6) * 51;
+    return [r, g, b];
+}
+/** @type {(r: number, g: number, b: number) => number} */
+function rgbToX16(r, g, b) {
+    // First calculate it as a 4x4x4 cube.
+    r = Math.min(2, Math.floor(r / 85));
+    g = Math.min(2, Math.floor(g / 85));
+    b = Math.min(2, Math.floor(b / 85));
+    // Which channels are "on" determines the hue (ANSI color index 0–7).
+    const index = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0);
+    // The bright bit is derived from the max channel level across all three.
+    const twos = (r === 2 ? 1 : 0) + (g === 2 ? 1 : 0) + (b === 2 ? 1 : 0);
+    const ones = (r === 1 ? 1 : 0) + (g === 1 ? 1 : 0) + (b === 1 ? 1 : 0);
+    const bright = twos > 0 && twos >= ones;
+    // Return value uses the SGR offset scheme: 0–7 for normal, 60–67 for bright.
+    return index + (bright ? 60 : 0);
+}
+/** @type {(r: number, g: number, b: number) => number} */
+function rgbToX8(r, g, b) {
+    r = r >= 128 ? 1 : 0;
+    g = g >= 128 ? 1 : 0;
+    b = b >= 128 ? 1 : 0;
+    return (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0);
+}
+/**
+ * @overload
+ * @param   {number} x
+ * @returns {number}
+ * @overload
+ * @param   {number} r
+ * @param   {number} g
+ * @param   {number} b
+ * @returns {[number, number, number]}
+ */ /** @param {[number] | [number, number, number]} args */
+const clip = (...args) => args.length === 1 ?
+    Math.max(0, Math.min(255, Math.floor(args[0]))) :
+    [
+        Math.max(0, Math.min(255, Math.floor(args[0]))),
+        Math.max(0, Math.min(255, Math.floor(args[1]))),
+        Math.max(0, Math.min(255, Math.floor(args[2]))),
+    ];
+module.exports = { rgbToX256, x256ToRgb, rgbToX16, rgbToX8, clip };

package/dist/sgr/index.d.ts

@@ -1,59 +1,9 @@
 declare const _exports: {
-    fg: {
-        black: import("./sgr").SGR;
-        red: import("./sgr").SGR;
-        green: import("./sgr").SGR;
-        yellow: import("./sgr").SGR;
-        blue: import("./sgr").SGR;
-        magenta: import("./sgr").SGR;
-        cyan: import("./sgr").SGR;
-        white: import("./sgr").SGR;
-        brightBlack: import("./sgr").SGR;
-        brightRed: import("./sgr").SGR;
-        brightGreen: import("./sgr").SGR;
-        brightYellow: import("./sgr").SGR;
-        brightBlue: import("./sgr").SGR;
-        brightMagenta: import("./sgr").SGR;
-        brightCyan: import("./sgr").SGR;
-        brightWhite: import("./sgr").SGR;
-        default: string;
-        rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
+    makeColor: (colorDepth: ColorDepth) => {
+        fg: Channel;
+        bg: Channel;
     };
-    bg: {
-        black: import("./sgr").SGR;
-        red: import("./sgr").SGR;
-        green: import("./sgr").SGR;
-        yellow: import("./sgr").SGR;
-        blue: import("./sgr").SGR;
-        magenta: import("./sgr").SGR;
-        cyan: import("./sgr").SGR;
-        white: import("./sgr").SGR;
-        brightBlack: import("./sgr").SGR;
-        brightRed: import("./sgr").SGR;
-        brightGreen: import("./sgr").SGR;
-        brightYellow: import("./sgr").SGR;
-        brightBlue: import("./sgr").SGR;
-        brightMagenta: import("./sgr").SGR;
-        brightCyan: import("./sgr").SGR;
-        brightWhite: import("./sgr").SGR;
-        default: string;
-        rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
-    };
-    style: {
-        bold: import("./sgr").SGR;
-        dim: import("./sgr").SGR;
-        italic: import("./sgr").SGR;
-        underline: import("./sgr").SGR;
-        inverse: import("./sgr").SGR;
-        hidden: import("./sgr").SGR;
-        strikethrough: import("./sgr").SGR;
-        doubleUnderline: import("./sgr").SGR;
-        frame: import("./sgr").SGR;
-        encircle: import("./sgr").SGR;
-        overline: import("./sgr").SGR;
-    };
-    reset: "\u001B[0m";
+    makeStyle: typeof import("./style").makeStyle;
+    makeReset: (enabled?: boolean) => "" | "\u001B[0m";
 };
 export = _exports;

package/dist/sgr/reset.d.ts

@@ -1 +1 @@
-export const reset: "\u001B[0m";
+export function makeReset(enabled?: boolean): "" | "\u001B[0m";

package/dist/sgr/reset.js

@@ -1,3 +1,3 @@
 "use strict";
-const reset = "\x1b[0m";
-module.exports = { reset };
+const makeReset = (enabled = true) => enabled ? "\x1b[0m" : "";
+module.exports = { makeReset };

package/dist/sgr/sgr.d.ts

@@ -3,12 +3,12 @@ export type SGR = {
     (text: string): string;
     open: string;
     close: string;
-    [$codes]: {
+    codes: {
         open: Code;
         close: Code;
     };
     combine: (...styles: SGR[]) => SGR;
 };
-export function sgr(open: Code, close: Code, reset?: boolean): SGR;
-declare const $codes: unique symbol;
+export function makeSGR(enabled?: boolean): typeof sgr;
+declare function sgr(open: Code, close: Code, reset?: boolean): SGR;
 export {};

package/dist/sgr/sgr.js

@@ -1,13 +1,12 @@
 "use strict";
-const $codes = Symbol();
 /**
 @typedef {number | number[]} Code
 @typedef {{
     (text: string): string;
-    open     : string;
-    close    : string;
-    [$codes] : {open: Code, close: Code};
-    combine  : (...styles: SGR[]) => SGR;
+    open    : string;
+    close   : string;
+    codes   : {open: Code, close: Code};
+    combine : (...styles: SGR[]) => SGR;
 }} SGR
 */
 /** @type {(code: Code, codes: Code[]) => Code} */
@@ -37,11 +36,22 @@ function sgr(open, close, reset = false) {
     /** @type {(text: string) => string} */
     const func = s => openSequence + s.replace(rxClose, replace) + closeSequence;
     return Object.assign(func, {
-        [$codes]: { open, close },
+        codes: { open, close },
         open: openSequence,
         close: closeSequence,
         /** @type {(...styles: SGR[]) => SGR} */
-        combine: (...styles) => sgr(combine(open, styles.map(s => s[$codes].open)), combine(close, styles.map(s => s[$codes].close))),
+        combine: (...styles) => sgr(combine(open, styles.map(s => s.codes.open)), combine(close, styles.map(s => s.codes.close))),
     });
 }
-module.exports = { sgr };
+;
+/** @type {SGR} */
+const disabledSGR = Object.assign(/** @type {(text: string) => string} */ /** @type {(text: string) => string} */ s => s, {
+    codes: { open: 0, close: 0 },
+    open: "",
+    close: "",
+    combine: () => disabledSGR,
+});
+/** @type {typeof sgr} */
+const disabled = () => disabledSGR;
+const makeSGR = (enabled = true) => enabled ? sgr : disabled;
+module.exports = { makeSGR };

package/dist/sgr/style.d.ts

@@ -1,13 +1,13 @@
-export namespace style {
-    let bold: import("./sgr").SGR;
-    let dim: import("./sgr").SGR;
-    let italic: import("./sgr").SGR;
-    let underline: import("./sgr").SGR;
-    let inverse: import("./sgr").SGR;
-    let hidden: import("./sgr").SGR;
-    let strikethrough: import("./sgr").SGR;
-    let doubleUnderline: import("./sgr").SGR;
-    let frame: import("./sgr").SGR;
-    let encircle: import("./sgr").SGR;
-    let overline: import("./sgr").SGR;
-}
+export function makeStyle(enabled?: boolean): {
+    bold: import("./sgr").SGR;
+    dim: import("./sgr").SGR;
+    italic: import("./sgr").SGR;
+    underline: import("./sgr").SGR;
+    inverse: import("./sgr").SGR;
+    hidden: import("./sgr").SGR;
+    strikethrough: import("./sgr").SGR;
+    doubleUnderline: import("./sgr").SGR;
+    frame: import("./sgr").SGR;
+    encircle: import("./sgr").SGR;
+    overline: import("./sgr").SGR;
+};

package/dist/sgr/style.js

@@ -1,16 +1,19 @@
 "use strict";
-const { sgr } = require("./sgr");
-const style = {
-    bold: sgr(1, 22, true),
-    dim: sgr(2, 22, true),
-    italic: sgr(3, 23),
-    underline: sgr(4, 24),
-    inverse: sgr(7, 27),
-    hidden: sgr(8, 28),
-    strikethrough: sgr(9, 29),
-    doubleUnderline: sgr(21, 24),
-    frame: sgr(51, 54),
-    encircle: sgr(52, 54),
-    overline: sgr(53, 55),
-};
-module.exports = { style };
+const { makeSGR } = require("./sgr");
+function makeStyle(enabled = true) {
+    const sgr = makeSGR(enabled);
+    return {
+        bold: sgr(1, 22, true),
+        dim: sgr(2, 22, true),
+        italic: sgr(3, 23),
+        underline: sgr(4, 24),
+        inverse: sgr(7, 27),
+        hidden: sgr(8, 28),
+        strikethrough: sgr(9, 29),
+        doubleUnderline: sgr(21, 24),
+        frame: sgr(51, 54),
+        encircle: sgr(52, 54),
+        overline: sgr(53, 55),
+    };
+}
+module.exports = { makeStyle };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name"            : "@peteanderson/ansi",
-	"version"         : "0.2.3",
+	"version"         : "0.3.0",
 	"description"     : "ANSI escape sequence generation with automatic feature detection",
 	"author"          : {
 		"name"  : "Pete Anderson",

package/src/ansi.js

@@ -1,28 +1,58 @@
 "use strict";
 
-const caret                            = require("./caret");
-const erase                            = require("./erase");
-const scroll                           = require("./scroll");
-const {bg, fg, reset, style}           = require("./sgr");
-const {simplify}                       = require("./simplify");
-const {slice}                          = require("./slice");
-const {sanitize, strip, visibleLength} = require("./strip");
-
-const ansi = {
-	caret,
-	erase,
-	scroll,
-
-	reset,
-	style,
-	fg,
-	bg,
-
-	strip,
-	visibleLength,
-	sanitize,
-	slice,
-	simplify,
-};
+const {makeCaret}                       = require("./caret");
+const {makeErase}                       = require("./erase");
+const {getFeatures}                     = require("./features");
+const {makeScroll}                      = require("./scroll");
+const {makeColor, makeReset, makeStyle} = require("./sgr");
+const {simplify}                        = require("./simplify");
+const {slice}                           = require("./slice");
+const {sanitize, strip, visibleLength}  = require("./strip");
+
+/**
+@typedef {import("./features/features").Args} Args
+
+@typedef {ReturnType<typeof makeColor> & {
+	caret  : ReturnType<typeof makeCaret>;
+	erase  : ReturnType<typeof makeErase>;
+	scroll : ReturnType<typeof makeScroll>;
+
+	reset : string;
+	style : ReturnType<typeof makeStyle>;
+
+	strip         : typeof strip;
+	visibleLength : typeof visibleLength;
+	sanitize      : typeof sanitize;
+	slice         : typeof slice;
+	simplify      : typeof simplify;
+
+	features : ReturnType<typeof getFeatures>;
+}} Ansi
+*/
+
+/** @type {(...args: Args) => Ansi}*/
+function makeAnsi(...args) {
+	const features = getFeatures(...args);
+
+	return {
+		caret  : makeCaret(features.caret),
+		erase  : makeErase(features.erase),
+		scroll : makeScroll(features.scroll),
+
+		reset : makeReset(features.colorDepth > 1),
+		style : makeStyle(features.style),
+		...makeColor(features.colorDepth),
+
+		strip,
+		visibleLength,
+		sanitize,
+		slice,
+		simplify,
+
+		features,
+	};
+}
+
+const ansi = Object.assign(makeAnsi, makeAnsi());
 
 module.exports = ansi;

package/src/caret.js

@@ -1,8 +1,10 @@
 "use strict";
 
 /** @type {(code: string) => (count?: number) => string} */
-const move = code =>
-	count => `\x1b[${count === undefined ? "" : count ? count : "?"}${code}`;
+const move = code => count => `\x1b[${count === undefined ? "" : count ? count : "?"}${code}`;
+
+/** @type {(count?: number) => string} */
+const noop = () => "";
 
 const caret = {
 	up       : move("A"),
@@ -46,4 +48,39 @@ const caret = {
 	},
 };
 
-module.exports = caret;
+/** @type {typeof caret} */
+const disabled = {
+	up       : noop,
+	down     : noop,
+	forward  : noop,
+	backward : noop,
+	nextLine : noop,
+	prevLine : noop,
+
+	x: noop,
+
+	save    : "",
+	restore : "",
+
+	hide : "",
+	show : "",
+
+	position: {
+		get: "",
+		set: noop,
+	},
+
+	shape: {
+		steadyBlock       : "",
+		steadyBar         : "",
+		steadyUnderline   : "",
+		blinkingBlock     : "",
+		blinkingBar       : "",
+		blinkingUnderline : "",
+		default           : "",
+	},
+};
+
+const makeCaret = (enabled = true) => enabled ? caret : disabled;
+
+module.exports = {makeCaret};