const styles = {
    modifier: {
        reset: [0, 0],
        // 21 isn't widely supported and 22 does the same thing
        bold: [1, 22],
        dim: [2, 22],
        italic: [3, 23],
        underline: [4, 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],
        // Bright color
        blackBright: [90, 39],
        gray: [90, 39], // Alias of `blackBright`
        grey: [90, 39], // Alias of `blackBright`
        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],
        // Bright color
        bgBlackBright: [100, 49],
        bgGray: [100, 49], // Alias of `bgBlackBright`
        bgGrey: [100, 49], // Alias of `bgBlackBright`
        bgRedBright: [101, 49],
        bgGreenBright: [102, 49],
        bgYellowBright: [103, 49],
        bgBlueBright: [104, 49],
        bgMagentaBright: [105, 49],
        bgCyanBright: [106, 49],
        bgWhiteBright: [107, 49],
    },
};
export const modifierNames = Object.keys(styles.modifier);
export const foregroundColorNames = Object.keys(styles.color);
export const backgroundColorNames = Object.keys(styles.bgColor);
export const colorNames = [...foregroundColorNames, ...backgroundColorNames];
class AnsiStyles {
}
export const codes = new Map();
const ingest = (set) => Object.fromEntries(Object.entries(set).map(([key, [open, close]]) => {
    codes.set(open, close);
    return [
        key,
        (AnsiStyles.prototype[key] = {
            open: `\u001B[${open}m`,
            close: `\u001B[${close}m`,
        }),
    ];
}));
export const ansiStyles = new (class extends AnsiStyles {
    codes = codes;
    modifier = ingest(styles.modifier);
    color = {
        ...ingest(styles.color),
        close: "\x1B[39m",
        ansi: (code) => `\u001B[${code}m`,
        ansi256: (code) => `\u001B[${38};5;${code}m`,
        ansi16m: (red, green, blue) => `\u001B[${38};2;${red};${green};${blue}m`,
    };
    bgColor = {
        ...ingest(styles.bgColor),
        close: "\u001B[49m",
        ansi: (code) => `\u001B[${code + 10}m`,
        ansi256: (code) => `\u001B[${48};5;${code}m`,
        ansi16m: (red, green, blue) => `\u001B[${48};2;${red};${green};${blue}m`,
    };
    rgbToAnsi256(red, green, blue) {
        // We use the extended greyscale palette here, with the exception of
        // black and white. normal palette only has 4 greyscale shades.
        if (red === green && green === blue) {
            if (red < 8)
                return 16;
            if (red > 248)
                return 231;
            return Math.round(((red - 8) / 247) * 24) + 232;
        }
        return (16 +
            36 * Math.round((red / 255) * 5) +
            6 * Math.round((green / 255) * 5) +
            Math.round((blue / 255) * 5));
    }
    hexToRgb(hex) {
        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
        if (!matches) {
            return [0, 0, 0];
        }
        let [colorString] = matches;
        if (colorString.length === 3) {
            colorString = [...colorString]
                .map((character) => character + character)
                .join("");
        }
        const integer = Number.parseInt(colorString, 16);
        return [
            (integer >> 16) & 0xff,
            (integer >> 8) & 0xff,
            integer & 0xff,
        ];
    }
    hexToAnsi256(hex) {
        return this.rgbToAnsi256(...this.hexToRgb(hex));
    }
    ansi256ToAnsi(code) {
        if (code < 8) {
            return 30 + code;
        }
        if (code < 16) {
            return 90 + (code - 8);
        }
        let red;
        let green;
        let blue;
        if (code >= 232) {
            red = ((code - 232) * 10 + 8) / 255;
            green = red;
            blue = red;
        }
        else {
            code -= 16;
            const remainder = code % 36;
            red = Math.floor(code / 36) / 5;
            green = Math.floor(remainder / 6) / 5;
            blue = (remainder % 6) / 5;
        }
        const value = Math.max(red, green, blue) * 2;
        if (value === 0) {
            return 30;
        }
        let result = 30 +
            ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
        if (value === 2) {
            result += 60;
        }
        return result;
    }
    rgbToAnsi(red, green, blue) {
        return this.ansi256ToAnsi(this.rgbToAnsi256(red, green, blue));
    }
    hexToAnsi(hex) {
        return this.ansi256ToAnsi(this.hexToAnsi256(hex));
    }
})();
//# sourceMappingURL=index.js.map