@bleedingdev/modern-js-utils 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/compiled/chalk/index.mjs

@@ -0,0 +1,761 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+var e = {};
+(()=>{
+    e.d = (r, n)=>{
+        for(var t in n)if (e.o(n, t) && !e.o(r, t)) Object.defineProperty(r, t, {
+            enumerable: true,
+            get: n[t]
+        });
+    };
+})();
+(()=>{
+    e.o = (e, r)=>Object.prototype.hasOwnProperty.call(e, r);
+})();
+var r = {};
+e.d(r, {
+    g7: ()=>Chalk,
+    sT: ()=>i,
+    t0: ()=>i,
+    _w: ()=>j,
+    i4: ()=>c,
+    Tj: ()=>c,
+    Ay: ()=>x,
+    zH: ()=>l,
+    Ky: ()=>l,
+    cf: ()=>s,
+    Dv: ()=>s,
+    WI: ()=>O,
+    Yl: ()=>T,
+    Sl: ()=>a
+});
+function stringReplaceAll(e, r, n) {
+    let t = e.indexOf(r);
+    if (-1 === t) return e;
+    const o = r.length;
+    let s = 0;
+    let l = "";
+    do {
+        l += e.slice(s, t) + r + n;
+        s = t + o;
+        t = e.indexOf(r, s);
+    }while (-1 !== t);
+    l += e.slice(s);
+    return l;
+}
+function stringEncaseCRLFWithFirstIndex(e, r, n, t) {
+    let o = 0;
+    let s = "";
+    do {
+        const l = "\r" === e[t - 1];
+        s += e.slice(o, l ? t - 1 : t) + r + (l ? "\r\n" : "\n") + n;
+        o = t + 1;
+        t = e.indexOf("\n", o);
+    }while (-1 !== t);
+    s += e.slice(o);
+    return s;
+}
+const n = 10;
+const t = 20;
+const wrapAnsi16 = (e = 0)=>(r)=>`[${r + e}m`;
+const wrapAnsi256 = (e = 0)=>(r)=>`[${38 + e};5;${r}m`;
+const wrapAnsi16m = (e = 0)=>(r, n, t)=>`[${38 + e};2;${r};${n};${t}m`;
+const wrapUnderlineAnsi = (e)=>`[58;5;${e < 90 ? e - 30 : e - 90 + 8}m`;
+const o = {
+    modifier: {
+        reset: [
+            0,
+            0
+        ],
+        bold: [
+            1,
+            22
+        ],
+        dim: [
+            2,
+            22
+        ],
+        italic: [
+            3,
+            23
+        ],
+        underline: [
+            4,
+            24
+        ],
+        underlineDouble: [
+            "4:2",
+            24
+        ],
+        underlineCurly: [
+            "4:3",
+            24
+        ],
+        underlineDotted: [
+            "4:4",
+            24
+        ],
+        underlineDashed: [
+            "4:5",
+            24
+        ],
+        overline: [
+            53,
+            55
+        ],
+        inverse: [
+            7,
+            27
+        ],
+        hidden: [
+            8,
+            28
+        ],
+        strikethrough: [
+            9,
+            29
+        ]
+    },
+    color: {
+        black: [
+            30,
+            39
+        ],
+        red: [
+            31,
+            39
+        ],
+        green: [
+            32,
+            39
+        ],
+        yellow: [
+            33,
+            39
+        ],
+        blue: [
+            34,
+            39
+        ],
+        magenta: [
+            35,
+            39
+        ],
+        cyan: [
+            36,
+            39
+        ],
+        white: [
+            37,
+            39
+        ],
+        blackBright: [
+            90,
+            39
+        ],
+        gray: [
+            90,
+            39
+        ],
+        grey: [
+            90,
+            39
+        ],
+        redBright: [
+            91,
+            39
+        ],
+        greenBright: [
+            92,
+            39
+        ],
+        yellowBright: [
+            93,
+            39
+        ],
+        blueBright: [
+            94,
+            39
+        ],
+        magentaBright: [
+            95,
+            39
+        ],
+        cyanBright: [
+            96,
+            39
+        ],
+        whiteBright: [
+            97,
+            39
+        ]
+    },
+    bgColor: {
+        bgBlack: [
+            40,
+            49
+        ],
+        bgRed: [
+            41,
+            49
+        ],
+        bgGreen: [
+            42,
+            49
+        ],
+        bgYellow: [
+            43,
+            49
+        ],
+        bgBlue: [
+            44,
+            49
+        ],
+        bgMagenta: [
+            45,
+            49
+        ],
+        bgCyan: [
+            46,
+            49
+        ],
+        bgWhite: [
+            47,
+            49
+        ],
+        bgBlackBright: [
+            100,
+            49
+        ],
+        bgGray: [
+            100,
+            49
+        ],
+        bgGrey: [
+            100,
+            49
+        ],
+        bgRedBright: [
+            101,
+            49
+        ],
+        bgGreenBright: [
+            102,
+            49
+        ],
+        bgYellowBright: [
+            103,
+            49
+        ],
+        bgBlueBright: [
+            104,
+            49
+        ],
+        bgMagentaBright: [
+            105,
+            49
+        ],
+        bgCyanBright: [
+            106,
+            49
+        ],
+        bgWhiteBright: [
+            107,
+            49
+        ]
+    },
+    underlineColor: {
+        underlineBlack: [
+            "58;5;0",
+            59
+        ],
+        underlineRed: [
+            "58;5;1",
+            59
+        ],
+        underlineGreen: [
+            "58;5;2",
+            59
+        ],
+        underlineYellow: [
+            "58;5;3",
+            59
+        ],
+        underlineBlue: [
+            "58;5;4",
+            59
+        ],
+        underlineMagenta: [
+            "58;5;5",
+            59
+        ],
+        underlineCyan: [
+            "58;5;6",
+            59
+        ],
+        underlineWhite: [
+            "58;5;7",
+            59
+        ],
+        underlineBlackBright: [
+            "58;5;8",
+            59
+        ],
+        underlineGray: [
+            "58;5;8",
+            59
+        ],
+        underlineGrey: [
+            "58;5;8",
+            59
+        ],
+        underlineRedBright: [
+            "58;5;9",
+            59
+        ],
+        underlineGreenBright: [
+            "58;5;10",
+            59
+        ],
+        underlineYellowBright: [
+            "58;5;11",
+            59
+        ],
+        underlineBlueBright: [
+            "58;5;12",
+            59
+        ],
+        underlineMagentaBright: [
+            "58;5;13",
+            59
+        ],
+        underlineCyanBright: [
+            "58;5;14",
+            59
+        ],
+        underlineWhiteBright: [
+            "58;5;15",
+            59
+        ]
+    }
+};
+const s = Object.keys(o.modifier);
+const l = Object.keys(o.color);
+const i = Object.keys(o.bgColor);
+const a = Object.keys(o.underlineColor);
+const c = [
+    ...l,
+    ...i
+];
+function assembleStyles() {
+    const e = new Map;
+    for (const [r, n] of Object.entries(o)){
+        for (const [r, t] of Object.entries(n)){
+            o[r] = {
+                open: `[${t[0]}m`,
+                close: `[${t[1]}m`
+            };
+            n[r] = o[r];
+            e.set(Number.parseInt(t[0], 10), t[1]);
+        }
+        Object.defineProperty(o, r, {
+            value: n,
+            enumerable: false
+        });
+    }
+    Object.defineProperty(o, "codes", {
+        value: e,
+        enumerable: false
+    });
+    o.color.close = "";
+    o.bgColor.close = "";
+    o.underlineColor.close = "";
+    o.color.ansi = wrapAnsi16();
+    o.color.ansi256 = wrapAnsi256();
+    o.color.ansi16m = wrapAnsi16m();
+    o.bgColor.ansi = wrapAnsi16(n);
+    o.bgColor.ansi256 = wrapAnsi256(n);
+    o.bgColor.ansi16m = wrapAnsi16m(n);
+    o.underlineColor.ansi = wrapUnderlineAnsi;
+    o.underlineColor.ansi256 = wrapAnsi256(t);
+    o.underlineColor.ansi16m = wrapAnsi16m(t);
+    Object.defineProperties(o, {
+        rgbToAnsi256: {
+            value (e, r, n) {
+                if (e === r && r === n) {
+                    if (e < 8) return 16;
+                    if (e > 248) return 231;
+                    return Math.round((e - 8) / 247 * 24) + 232;
+                }
+                return 16 + 36 * Math.round(e / 255 * 5) + 6 * Math.round(r / 255 * 5) + Math.round(n / 255 * 5);
+            },
+            enumerable: false
+        },
+        hexToRgb: {
+            value (e) {
+                const r = /[\da-f]{6}|[\da-f]{3}/i.exec(e.toString(16));
+                if (!r) return [
+                    0,
+                    0,
+                    0
+                ];
+                let [n] = r;
+                if (3 === n.length) n = [
+                    ...n
+                ].map((e)=>e + e).join("");
+                const t = Number.parseInt(n, 16);
+                return [
+                    t >> 16 & 255,
+                    t >> 8 & 255,
+                    255 & t
+                ];
+            },
+            enumerable: false
+        },
+        hexToAnsi256: {
+            value: (e)=>o.rgbToAnsi256(...o.hexToRgb(e)),
+            enumerable: false
+        },
+        ansi256ToAnsi: {
+            value (e) {
+                if (e < 8) return 30 + e;
+                if (e < 16) return 90 + (e - 8);
+                let r;
+                let n;
+                let t;
+                if (e >= 232) {
+                    r = ((e - 232) * 10 + 8) / 255;
+                    n = r;
+                    t = r;
+                } else {
+                    e -= 16;
+                    const o = e % 36;
+                    r = Math.floor(e / 36) / 5;
+                    n = Math.floor(o / 6) / 5;
+                    t = o % 6 / 5;
+                }
+                const o = 2 * Math.max(r, n, t);
+                if (0 === o) return 30;
+                let s = 30 + (Math.round(t) << 2 | Math.round(n) << 1 | Math.round(r));
+                if (2 === o) s += 60;
+                return s;
+            },
+            enumerable: false
+        },
+        rgbToAnsi: {
+            value: (e, r, n)=>o.ansi256ToAnsi(o.rgbToAnsi256(e, r, n)),
+            enumerable: false
+        },
+        hexToAnsi: {
+            value: (e)=>o.ansi256ToAnsi(o.hexToAnsi256(e)),
+            enumerable: false
+        }
+    });
+    return o;
+}
+const u = assembleStyles();
+const f = u;
+const h = require("node:process");
+const g = require("node:os");
+const d = require("node:tty");
+function hasFlag(e, r = globalThis.Deno ? globalThis.Deno.args : h.argv) {
+    const n = e.startsWith("-") ? "" : 1 === e.length ? "-" : "--";
+    const t = r.indexOf(n + e);
+    const o = r.indexOf("--");
+    return -1 !== t && (-1 === o || t < o);
+}
+const { env: b } = h;
+let m;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) m = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) m = 1;
+function hasNumericForceColor() {
+    return /^\d+$/.test(b.FORCE_COLOR);
+}
+function envForceColor() {
+    if (!("FORCE_COLOR" in b)) return;
+    if ("false" === b.FORCE_COLOR) return 0;
+    if ("true" === b.FORCE_COLOR || 0 === b.FORCE_COLOR.length) return 1;
+    if (!hasNumericForceColor()) return;
+    return Math.min(Number.parseInt(b.FORCE_COLOR, 10), 3);
+}
+function translateLevel(e) {
+    if (0 === e) return false;
+    return {
+        level: e,
+        hasBasic: true,
+        has256: e >= 2,
+        has16m: e >= 3
+    };
+}
+function _supportsColor(e, { streamIsTTY: r, sniffFlags: n = true } = {}) {
+    const t = envForceColor();
+    if (void 0 !== t) m = t;
+    const o = n ? m : t;
+    if (0 === o) return 0;
+    if (n) {
+        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+        if (hasFlag("color=256")) return 2;
+    }
+    if (void 0 !== o && hasNumericForceColor()) return o;
+    if ("TF_BUILD" in b && "AGENT_NAME" in b) return 1;
+    if (e && !r && void 0 === o) return 0;
+    const s = o || 0;
+    if ("dumb" === b.TERM) return s;
+    if ("win32" === h.platform) {
+        const e = g.release().split(".");
+        if (Number(e[0]) >= 10 && Number(e[2]) >= 10586) return Number(e[2]) >= 14931 ? 3 : 2;
+        return 1;
+    }
+    if ("CI" in b) {
+        if ([
+            "GITHUB_ACTIONS",
+            "GITEA_ACTIONS",
+            "CIRCLECI"
+        ].some((e)=>e in b)) return 3;
+        if ([
+            "TRAVIS",
+            "APPVEYOR",
+            "GITLAB_CI",
+            "BUILDKITE",
+            "DRONE"
+        ].some((e)=>e in b) || "codeship" === b.CI_NAME) return 1;
+        return s;
+    }
+    if ("TEAMCITY_VERSION" in b) return /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(b.TEAMCITY_VERSION) ? 1 : 0;
+    if ("truecolor" === b.COLORTERM) return 3;
+    if ("xterm-kitty" === b.TERM) return 3;
+    if ("xterm-ghostty" === b.TERM) return 3;
+    if ("wezterm" === b.TERM) return 3;
+    if ("TERM_PROGRAM" in b) {
+        const e = Number.parseInt((b.TERM_PROGRAM_VERSION || "").split(".", 1)[0], 10);
+        switch(b.TERM_PROGRAM){
+            case "iTerm.app":
+                return e >= 3 ? 3 : 2;
+            case "Apple_Terminal":
+                return 2;
+        }
+    }
+    if (/-256(?:color)?$/i.test(b.TERM)) return 2;
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(b.TERM)) return 1;
+    if ("COLORTERM" in b) return 1;
+    return s;
+}
+function createSupportsColor(e, r = {}) {
+    const n = _supportsColor(e, {
+        streamIsTTY: e && e.isTTY,
+        ...r
+    });
+    return translateLevel(n);
+}
+const C = {
+    stdout: createSupportsColor({
+        isTTY: d.isatty(1)
+    }),
+    stderr: createSupportsColor({
+        isTTY: d.isatty(2)
+    })
+};
+const p = C;
+const { stdout: O, stderr: T } = p;
+const v = Symbol("GENERATOR");
+const R = Symbol("STYLER");
+const y = Symbol("IS_EMPTY");
+const A = Symbol("LEVEL");
+const E = Object.create(null);
+const assertValidLevel = (e)=>{
+    if (!Number.isSafeInteger(e) || e < 0 || e > 3) throw new Error("The `level` should be an integer from 0 to 3");
+};
+const B = {
+    enumerable: true,
+    get () {
+        return this[A];
+    },
+    set (e) {
+        assertValidLevel(e);
+        this[A] = e;
+    }
+};
+const applyOptions = (e, r = {})=>{
+    if (void 0 !== r.level) assertValidLevel(r.level);
+    const n = O ? O.level : 0;
+    e[A] = void 0 === r.level ? n : r.level;
+};
+class Chalk {
+    constructor(e){
+        return chalkFactory(e);
+    }
+}
+const chalkFactory = (e)=>{
+    const chalk = (...e)=>e.join(" ");
+    applyOptions(chalk, e);
+    Object.setPrototypeOf(chalk, createChalk.prototype);
+    return chalk;
+};
+function createChalk(e) {
+    return chalkFactory(e);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [e, r] of Object.entries(f))E[e] = {
+    get () {
+        const n = createBuilder(this, createStyler(r.open, r.close, this[R]), this[y]);
+        Object.defineProperty(this, e, {
+            value: n
+        });
+        return n;
+    }
+};
+E.visible = {
+    get () {
+        const e = createBuilder(this, this[R], true);
+        Object.defineProperty(this, "visible", {
+            value: e
+        });
+        return e;
+    }
+};
+const createModelConverters = (e, r)=>{
+    const n = f[r];
+    if ("rgb" === e) {
+        const ansi = (e, r, t)=>n.ansi(f.rgbToAnsi(e, r, t));
+        const ansi256 = (e, r, t)=>n.ansi256(f.rgbToAnsi256(e, r, t));
+        return [
+            ansi,
+            ansi,
+            ansi256,
+            n.ansi16m
+        ];
+    }
+    if ("hex" === e) {
+        const ansi = (e)=>n.ansi(f.hexToAnsi(e));
+        const ansi256 = (e)=>n.ansi256(f.hexToAnsi256(e));
+        return [
+            ansi,
+            ansi,
+            ansi256,
+            (e)=>n.ansi16m(...f.hexToRgb(e))
+        ];
+    }
+    const ansi = (e)=>n.ansi(f.ansi256ToAnsi(e));
+    return [
+        ansi,
+        ansi,
+        n.ansi256,
+        n.ansi256
+    ];
+};
+const M = [
+    "rgb",
+    "hex",
+    "ansi256"
+];
+for (const e of M){
+    const r = e[0].toUpperCase() + e.slice(1);
+    for (const [n, t] of [
+        [
+            e,
+            "color"
+        ],
+        [
+            "bg" + r,
+            "bgColor"
+        ],
+        [
+            "underline" + r,
+            "underlineColor"
+        ]
+    ]){
+        const { close: r } = f[t];
+        const o = createModelConverters(e, t);
+        E[n] = {
+            get () {
+                const styleFunction = function(e, n, t) {
+                    const s = o[this.level](e, n, t);
+                    return createBuilder(this, createStyler(s, r, this[R]), this[y]);
+                };
+                Object.defineProperty(this, n, {
+                    value: styleFunction
+                });
+                return styleFunction;
+            }
+        };
+    }
+}
+const F = Object.defineProperties(()=>{}, {
+    ...E,
+    level: {
+        enumerable: true,
+        get () {
+            return this[v].level;
+        },
+        set (e) {
+            this[v].level = e;
+        }
+    }
+});
+const createStyler = (e, r, n)=>{
+    let t;
+    let o;
+    if (void 0 === n) {
+        t = e;
+        o = r;
+    } else {
+        t = n.openAll + e;
+        o = r + n.closeAll;
+    }
+    return {
+        open: e,
+        close: r,
+        openAll: t,
+        closeAll: o,
+        parent: n
+    };
+};
+const createBuilder = (e, r, n)=>{
+    const builder = (...e)=>{
+        if (1 === e.length) return applyStyle(builder, "" + e[0]);
+        if (2 === e.length) return applyStyle(builder, `${e[0] ?? ""} ${e[1] ?? ""}`);
+        return applyStyle(builder, e.join(" "));
+    };
+    Object.setPrototypeOf(builder, F);
+    builder[v] = e[v] ?? e;
+    builder[R] = r;
+    builder[y] = n;
+    return builder;
+};
+const applyStyle = (e, r)=>{
+    if (e[v][A] <= 0 || !r) return e[y] ? "" : r;
+    let n = e[R];
+    if (void 0 === n) return r;
+    const { openAll: t, closeAll: o } = n;
+    if (r.includes("")) while(void 0 !== n){
+        r = stringReplaceAll(r, n.close, n.open);
+        n = n.parent;
+    }
+    const s = r.indexOf("\n");
+    if (-1 !== s) r = stringEncaseCRLFWithFirstIndex(r, o, t, s);
+    return t + r + o;
+};
+Object.defineProperties(createChalk.prototype, {
+    ...E,
+    level: B
+});
+const I = createChalk();
+const j = createChalk({
+    level: T ? T.level : 0
+});
+const x = I;
+var N = r.g7;
+var k = r.sT;
+var _ = r.t0;
+var S = r._w;
+var w = r.i4;
+var L = r.Tj;
+var P = r.Ay;
+var G = r.zH;
+var Y = r.Ky;
+var $ = r.cf;
+var D = r.Dv;
+var W = r.WI;
+var V = r.Yl;
+var U = r.Sl;
+export { N as Chalk, k as backgroundColorNames, _ as backgroundColors, S as chalkStderr, w as colorNames, L as colors, P as default, G as foregroundColorNames, Y as foregroundColors, $ as modifierNames, D as modifiers, W as supportsColor, V as supportsColorStderr, U as underlineColorNames };