@visulima/colorize 1.4.25 → 1.4.27

package/dist/packem_shared/GradientBuilder-DjJK22kP.cjs

@@ -0,0 +1,491 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const convertHexToRgb = require('./convertHexToRgb-DvkHBM3-.cjs');
+
+const colorNames = {
+  aliceblue: [240, 248, 255],
+  antiquewhite: [250, 235, 215],
+  aqua: [0, 255, 255],
+  aquamarine: [127, 255, 212],
+  azure: [240, 255, 255],
+  beige: [245, 245, 220],
+  bisque: [255, 228, 196],
+  black: [0, 0, 0],
+  blanchedalmond: [255, 235, 205],
+  blue: [0, 0, 255],
+  blueviolet: [138, 43, 226],
+  brown: [165, 42, 42],
+  burlywood: [222, 184, 135],
+  cadetblue: [95, 158, 160],
+  chartreuse: [127, 255, 0],
+  chocolate: [210, 105, 30],
+  coral: [255, 127, 80],
+  cornflowerblue: [100, 149, 237],
+  cornsilk: [255, 248, 220],
+  crimson: [220, 20, 60],
+  cyan: [0, 255, 255],
+  darkblue: [0, 0, 139],
+  darkcyan: [0, 139, 139],
+  darkgoldenrod: [184, 134, 11],
+  darkgray: [169, 169, 169],
+  darkgreen: [0, 100, 0],
+  darkgrey: [169, 169, 169],
+  darkkhaki: [189, 183, 107],
+  darkmagenta: [139, 0, 139],
+  darkolivegreen: [85, 107, 47],
+  darkorange: [255, 140, 0],
+  darkorchid: [153, 50, 204],
+  darkred: [139, 0, 0],
+  darksalmon: [233, 150, 122],
+  darkseagreen: [143, 188, 143],
+  darkslateblue: [72, 61, 139],
+  darkslategray: [47, 79, 79],
+  darkslategrey: [47, 79, 79],
+  darkturquoise: [0, 206, 209],
+  darkviolet: [148, 0, 211],
+  deeppink: [255, 20, 147],
+  deepskyblue: [0, 191, 255],
+  dimgray: [105, 105, 105],
+  dimgrey: [105, 105, 105],
+  dodgerblue: [30, 144, 255],
+  firebrick: [178, 34, 34],
+  floralwhite: [255, 250, 240],
+  forestgreen: [34, 139, 34],
+  fuchsia: [255, 0, 255],
+  gainsboro: [220, 220, 220],
+  ghostwhite: [248, 248, 255],
+  gold: [255, 215, 0],
+  goldenrod: [218, 165, 32],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  greenyellow: [173, 255, 47],
+  grey: [128, 128, 128],
+  honeydew: [240, 255, 240],
+  hotpink: [255, 105, 180],
+  indianred: [205, 92, 92],
+  indigo: [75, 0, 130],
+  ivory: [255, 255, 240],
+  khaki: [240, 230, 140],
+  lavender: [230, 230, 250],
+  lavenderblush: [255, 240, 245],
+  lawngreen: [124, 252, 0],
+  lemonchiffon: [255, 250, 205],
+  lightblue: [173, 216, 230],
+  lightcoral: [240, 128, 128],
+  lightcyan: [224, 255, 255],
+  lightgoldenrodyellow: [250, 250, 210],
+  lightgray: [211, 211, 211],
+  lightgreen: [144, 238, 144],
+  lightgrey: [211, 211, 211],
+  lightpink: [255, 182, 193],
+  lightsalmon: [255, 160, 122],
+  lightseagreen: [32, 178, 170],
+  lightskyblue: [135, 206, 250],
+  lightslategray: [119, 136, 153],
+  lightslategrey: [119, 136, 153],
+  lightsteelblue: [176, 196, 222],
+  lightyellow: [255, 255, 224],
+  lime: [0, 255, 0],
+  limegreen: [50, 205, 50],
+  linen: [250, 240, 230],
+  magenta: [255, 0, 255],
+  maroon: [128, 0, 0],
+  mediumaquamarine: [102, 205, 170],
+  mediumblue: [0, 0, 205],
+  mediumorchid: [186, 85, 211],
+  mediumpurple: [147, 112, 219],
+  mediumseagreen: [60, 179, 113],
+  mediumslateblue: [123, 104, 238],
+  mediumspringgreen: [0, 250, 154],
+  mediumturquoise: [72, 209, 204],
+  mediumvioletred: [199, 21, 133],
+  midnightblue: [25, 25, 112],
+  mintcream: [245, 255, 250],
+  mistyrose: [255, 228, 225],
+  moccasin: [255, 228, 181],
+  navajowhite: [255, 222, 173],
+  navy: [0, 0, 128],
+  oldlace: [253, 245, 230],
+  olive: [128, 128, 0],
+  olivedrab: [107, 142, 35],
+  orange: [255, 165, 0],
+  orangered: [255, 69, 0],
+  orchid: [218, 112, 214],
+  palegoldenrod: [238, 232, 170],
+  palegreen: [152, 251, 152],
+  paleturquoise: [175, 238, 238],
+  palevioletred: [219, 112, 147],
+  papayawhip: [255, 239, 213],
+  peachpuff: [255, 218, 185],
+  peru: [205, 133, 63],
+  pink: [255, 192, 203],
+  plum: [221, 160, 221],
+  powderblue: [176, 224, 230],
+  purple: [128, 0, 128],
+  rebeccapurple: [102, 51, 153],
+  red: [255, 0, 0],
+  rosybrown: [188, 143, 143],
+  royalblue: [65, 105, 225],
+  saddlebrown: [139, 69, 19],
+  salmon: [250, 128, 114],
+  sandybrown: [244, 164, 96],
+  seagreen: [46, 139, 87],
+  seashell: [255, 245, 238],
+  sienna: [160, 82, 45],
+  silver: [192, 192, 192],
+  skyblue: [135, 206, 235],
+  slateblue: [106, 90, 205],
+  slategray: [112, 128, 144],
+  slategrey: [112, 128, 144],
+  snow: [255, 250, 250],
+  springgreen: [0, 255, 127],
+  steelblue: [70, 130, 180],
+  tan: [210, 180, 140],
+  teal: [0, 128, 128],
+  thistle: [216, 191, 216],
+  tomato: [255, 99, 71],
+  turquoise: [64, 224, 208],
+  violet: [238, 130, 238],
+  wheat: [245, 222, 179],
+  white: [255, 255, 255],
+  whitesmoke: [245, 245, 245],
+  yellow: [255, 255, 0],
+  yellowgreen: [154, 205, 50]
+};
+
+const computeSubSteps = (stops, steps) => {
+  const l = stops.length;
+  steps = Number.parseInt(steps.toString(), 10);
+  if (Number.isNaN(steps) || steps < 2) {
+    throw new Error("Invalid number of steps (< 2)");
+  }
+  if (steps < l) {
+    throw new Error("Number of steps cannot be inferior to number of stops");
+  }
+  const substeps = [];
+  for (let index = 1; index < l; index++) {
+    const step = (steps - 1) * (stops[index].position - stops[index - 1].position);
+    substeps.push(Math.max(1, Math.round(step)));
+  }
+  let totalSubsteps = 1;
+  for (let n = l - 1; n--; ) {
+    totalSubsteps += substeps[n];
+  }
+  while (totalSubsteps !== steps) {
+    if (totalSubsteps < steps) {
+      const min = Math.min(...substeps);
+      substeps[substeps.indexOf(min)]++;
+      totalSubsteps++;
+    } else {
+      const max = Math.max(...substeps);
+      substeps[substeps.indexOf(max)]--;
+      totalSubsteps--;
+    }
+  }
+  return substeps;
+};
+
+const hsvToRgb = (h, s, v) => {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  const index = Math.floor(h / 60);
+  const f = h / 60 - index;
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+  if (index % 6 === 0) {
+    r = v;
+    g = t;
+    b = p;
+  } else if (index % 6 === 1) {
+    r = q;
+    g = v;
+    b = p;
+  } else if (index % 6 === 2) {
+    r = p;
+    g = v;
+    b = t;
+  } else if (index % 6 === 3) {
+    r = p;
+    g = q;
+    b = v;
+  } else if (index % 6 === 4) {
+    r = t;
+    g = p;
+    b = v;
+  } else if (index % 6 === 5) {
+    r = v;
+    g = p;
+    b = q;
+  }
+  return { b: Math.round(b * 255), g: Math.round(g * 255), r: Math.round(r * 255) };
+};
+
+const rgbToHsv = ({ b, g, r }) => {
+  let rdif;
+  let gdif;
+  let bdif;
+  let h = 0;
+  let s = 0;
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const v = Math.max(r, g, b);
+  const diff = v - Math.min(r, g, b);
+  const diffc = (c) => (v - c) / 6 / diff + 1 / 2;
+  if (diff !== 0) {
+    s = diff / v;
+    rdif = diffc(r);
+    gdif = diffc(g);
+    bdif = diffc(b);
+    if (v === r) {
+      h = bdif - gdif;
+    } else if (v === g) {
+      h = 1 / 3 + rdif - bdif;
+    } else if (v === b) {
+      h = 2 / 3 + gdif - rdif;
+    }
+    if (h < 0) {
+      h += 1;
+    } else if (h > 1) {
+      h -= 1;
+    }
+  }
+  return {
+    h: h * 360,
+    s,
+    v
+  };
+};
+
+const RGBA_MAX = { b: 256, g: 256, r: 256 };
+const HSV_MAX = { h: 360, s: 1, v: 1 };
+const calculateStepSize = (start, end, steps) => {
+  const step = {};
+  for (const k in start) {
+    if (Object.prototype.hasOwnProperty.call(start, k)) {
+      step[k] = steps === 0 ? 0 : (end[k] - start[k]) / steps;
+    }
+  }
+  return step;
+};
+const interpolate = (step, start, index, max) => {
+  const color = {};
+  for (const k in start) {
+    if (Object.prototype.hasOwnProperty.call(start, k)) {
+      color[k] = step[k] * index + start[k];
+      color[k] = color[k] < 0 ? (
+        // eslint-disable-next-line security/detect-object-injection
+        color[k] + max[k]
+      ) : (
+        // eslint-disable-next-line security/detect-object-injection
+        max[k] === 1 ? (
+          // eslint-disable-next-line security/detect-object-injection
+          color[k]
+        ) : (
+          // eslint-disable-next-line security/detect-object-injection
+          color[k] % max[k]
+        )
+      );
+    }
+  }
+  return color;
+};
+const interpolateRgb = (stop1, stop2, steps) => {
+  const start = { b: stop1.color[2], g: stop1.color[1], r: stop1.color[0] };
+  const end = { b: stop2.color[2], g: stop2.color[1], r: stop2.color[0] };
+  const step = calculateStepSize(start, end, steps);
+  const gradient = [{ ...start }];
+  for (let index = 1; index < steps; index++) {
+    const color = interpolate(step, start, index, RGBA_MAX);
+    gradient.push({
+      b: Math.floor(color.b),
+      g: Math.floor(color.g),
+      r: Math.floor(color.r)
+    });
+  }
+  return gradient;
+};
+const interpolateHsv = (stop1, stop2, steps, mode) => {
+  const start = rgbToHsv({ b: stop1.color[2], g: stop1.color[1], r: stop1.color[0] });
+  const end = rgbToHsv({ b: stop2.color[2], g: stop2.color[1], r: stop2.color[0] });
+  if (start.s === 0 || end.s === 0) {
+    return interpolateRgb(stop1, stop2, steps);
+  }
+  let trigonometric;
+  if (typeof mode === "boolean") {
+    trigonometric = mode;
+  } else {
+    const trigShortest = start.h < end.h && end.h - start.h < 180 || start.h > end.h && start.h - end.h > 180;
+    trigonometric = mode === "long" && trigShortest || mode === "short" && !trigShortest;
+  }
+  const step = calculateStepSize(start, end, steps);
+  const gradient = [
+    {
+      b: stop1.color[2],
+      g: stop1.color[1],
+      r: stop1.color[0]
+    }
+  ];
+  let diff;
+  if (start.h <= end.h && !trigonometric || start.h >= end.h && trigonometric) {
+    diff = end.h - start.h;
+  } else if (trigonometric) {
+    diff = 360 - end.h + start.h;
+  } else {
+    diff = 360 - start.h + end.h;
+  }
+  step.h = (-1) ** (trigonometric ? 1 : 0) * Math.abs(diff) / steps;
+  for (let index = 1; index < steps; index++) {
+    const color = interpolate(step, start, index, HSV_MAX);
+    gradient.push(hsvToRgb(color.h, color.s, color.v));
+  }
+  return gradient;
+};
+
+class GradientBuilder {
+  #colorize;
+  stops;
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  constructor(colorize, stops) {
+    this.#colorize = colorize;
+    this.stops = [];
+    if (stops.length < 2) {
+      throw new Error("Invalid number of stops (< 2)");
+    }
+    const havingPositions = stops[0].position !== void 0;
+    let l = stops.length;
+    let p = -1;
+    let lastColorLess = false;
+    for (const [index, stop_] of stops.entries()) {
+      let stop = {};
+      const hasPosition = stop_.position !== void 0;
+      if (havingPositions !== hasPosition) {
+        throw new Error("Cannot mix positioned and non-positioned color stops");
+      }
+      if (hasPosition) {
+        const stopInput = stop_;
+        const hasColor = stopInput.color !== void 0;
+        if (!hasColor && (lastColorLess || index === 0 || index === l - 1)) {
+          throw new Error("Cannot define two consecutive position-only stops");
+        }
+        lastColorLess = !hasColor;
+        let color;
+        if (hasColor) {
+          if (Array.isArray(stopInput.color)) {
+            color = stopInput.color;
+          } else if (typeof stopInput.color === "string") {
+            color = stopInput.color.includes("#") ? convertHexToRgb.convertHexToRgb(stopInput.color) : colorNames[stopInput.color];
+          } else if (stopInput.color.r !== void 0 && stopInput.color.g !== void 0 && stopInput.color.b) {
+            color = [stopInput.color.r, stopInput.color.g, stopInput.color.b];
+          }
+        }
+        stop = {
+          color,
+          colorLess: !hasColor,
+          position: stopInput.position
+        };
+        if (stop.position < 0 || stop.position > 1) {
+          throw new Error("Color stops positions must be between 0 and 1");
+        } else if (stop.position < p) {
+          throw new Error("Color stops positions are not ordered");
+        }
+        p = stop.position;
+      } else if (Array.isArray(stop_)) {
+        stop = {
+          color: stop_,
+          position: index / (l - 1)
+        };
+      } else if (typeof stop_ === "string") {
+        stop = {
+          color: stop_.includes("#") ? convertHexToRgb.convertHexToRgb(stop_) : colorNames[stop_],
+          position: index / (l - 1)
+        };
+      } else if (stop_.r !== void 0 && stop_.g !== void 0 && stop_.b !== void 0) {
+        stop = {
+          color: [stop_.r, stop_.g, stop_.b],
+          position: index / (l - 1)
+        };
+      } else {
+        throw new Error("Invalid color stop");
+      }
+      this.stops.push(stop);
+    }
+    if (this.stops[0].position !== 0) {
+      this.stops.unshift({
+        color: this.stops[0].color,
+        position: 0
+      });
+      l++;
+    }
+    if (this.stops[l - 1].position !== 1) {
+      this.stops.push({
+        color: this.stops[l - 1].color,
+        position: 1
+      });
+    }
+  }
+  reverse() {
+    const stops = [];
+    for (const stop of this.stops) {
+      const stop_ = { ...stop };
+      stop_.position = 1 - stop.position;
+      stops.push(stop_);
+    }
+    return new GradientBuilder(this.#colorize, stops.reverse());
+  }
+  loop() {
+    const stops1 = [];
+    const stops2 = [];
+    for (const stop of this.stops) {
+      stops1.push({
+        color: stop.color,
+        position: (stop.position || 0) / 2
+      });
+    }
+    for (const stop of this.stops.slice(0, -1)) {
+      stops2.push({
+        color: stop.color,
+        position: 1 - (stop.position || 0) / 2
+      });
+    }
+    return new GradientBuilder(this.#colorize, [...stops1, ...stops2.reverse()]);
+  }
+  rgb(steps) {
+    const subSteps = computeSubSteps(this.stops, steps);
+    const gradient = [];
+    this.stops.forEach((stop, index) => {
+      if (stop.colorLess) {
+        const rgbs = interpolateRgb(this.stops[index - 1], this.stops[index + 1], 2);
+        stop.color = [rgbs[1].r, rgbs[1].g, rgbs[1].b];
+      }
+    });
+    for (let index = 0, l = this.stops.length; index < l - 1; index++) {
+      const rgbs = interpolateRgb(this.stops[index], this.stops[index + 1], subSteps[index]);
+      gradient.splice(gradient.length, 0, ...rgbs.map((rgb) => this.#colorize.rgb(rgb.r, rgb.g, rgb.b)));
+    }
+    gradient.push(this.#colorize.rgb(...this.stops.at(-1).color));
+    return gradient;
+  }
+  hsv(steps, mode = false) {
+    const subSteps = computeSubSteps(this.stops, steps);
+    const gradient = [];
+    this.stops.forEach((stop, index) => {
+      if (stop.colorLess) {
+        const rgbs = interpolateHsv(this.stops[index - 1], this.stops[index + 1], 2, mode);
+        stop.color = [rgbs[1].r, rgbs[1].g, rgbs[1].b];
+      }
+    });
+    for (let index = 0, l = this.stops.length; index < l - 1; index++) {
+      const rgbs = interpolateHsv(this.stops[index], this.stops[index + 1], subSteps[index], mode);
+      gradient.splice(gradient.length, 0, ...rgbs.map((rgb) => this.#colorize.rgb(rgb.r, rgb.g, rgb.b)));
+    }
+    gradient.push(this.#colorize.rgb(...this.stops.at(-1).color));
+    return gradient;
+  }
+}
+
+exports.GradientBuilder = GradientBuilder;

package/dist/packem_shared/colorize.server-BA3gZZXz.cjs

@@ -0,0 +1,193 @@
+'use strict';
+
+const isAnsiColorSupported = require('@visulima/is-ansi-color-supported');
+const convertHexToRgb = require('./convertHexToRgb-DvkHBM3-.cjs');
+const rgbToAnsi256 = require('./rgbToAnsi256-DL8eajTz.cjs');
+
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+const clamp = (number_, min, max) => min > number_ ? min : Math.min(number_, max);
+
+const closeCode = 39;
+const bgCloseCode = 49;
+const bgOffset = 10;
+const supportedColor = isAnsiColorSupported.isStdoutColorSupported();
+const mono = { close: "", open: "" };
+const esc = supportedColor > 0 ? (open, close) => {
+  return { close: `\x1B[${close}m`, open: `\x1B[${open}m` };
+} : () => mono;
+const createRgbFunction = (function_) => (r, g, b) => function_(rgbToAnsi256.rgbToAnsi256(Number(r), Number(g), Number(b)));
+const createHexFunction = (function_) => (hex) => {
+  const [r, g, b] = convertHexToRgb.convertHexToRgb(hex);
+  return function_(r, g, b);
+};
+let createAnsi256 = (code) => esc(`38;5;${code}`, closeCode);
+let createBgAnsi256 = (code) => esc(`48;5;${code}`, bgCloseCode);
+let createRgb = (r, g, b) => esc(`38;2;${r};${g};${b}`, closeCode);
+let createBgRgb = (r, g, b) => esc(`48;2;${r};${g};${b}`, bgCloseCode);
+if (supportedColor === 1) {
+  createAnsi256 = (code) => esc(rgbToAnsi256.ansi256To16(Number(code)), closeCode);
+  createBgAnsi256 = (code) => esc(rgbToAnsi256.ansi256To16(Number(code)) + bgOffset, bgCloseCode);
+  createRgb = (r, g, b) => esc(rgbToAnsi256.rgbToAnsi16(Number(r), Number(g), Number(b)), closeCode);
+  createBgRgb = (r, g, b) => esc(rgbToAnsi256.rgbToAnsi16(Number(r), Number(g), Number(b)) + bgOffset, bgCloseCode);
+} else if (supportedColor === 2) {
+  createRgb = createRgbFunction(createAnsi256);
+  createBgRgb = createRgbFunction(createBgAnsi256);
+}
+const baseStyles = {
+  // 21 isn't widely supported and 22 does the same thing
+  bold: esc(1, 22),
+  dim: esc(2, 22),
+  hidden: esc(8, 28),
+  inverse: esc(7, 27),
+  italic: esc(3, 23),
+  overline: esc(53, 55),
+  reset: esc(0, 0),
+  strike: esc(9, 29),
+  // alias for strikethrough
+  strikethrough: esc(9, 29),
+  underline: esc(4, 24),
+  visible: mono
+};
+const baseColors = {
+  bgBlack: esc(40, bgCloseCode),
+  bgBlackBright: esc(100, bgCloseCode),
+  bgBlue: esc(44, bgCloseCode),
+  bgBlueBright: esc(104, bgCloseCode),
+  bgCyan: esc(46, bgCloseCode),
+  bgCyanBright: esc(106, bgCloseCode),
+  bgGray: esc(100, bgCloseCode),
+  // US spelling alias for bgBlackBright
+  bgGreen: esc(42, bgCloseCode),
+  bgGreenBright: esc(102, bgCloseCode),
+  bgGrey: esc(100, bgCloseCode),
+  // UK spelling alias for bgBlackBright
+  bgMagenta: esc(45, bgCloseCode),
+  bgMagentaBright: esc(105, bgCloseCode),
+  bgRed: esc(41, bgCloseCode),
+  bgRedBright: esc(101, bgCloseCode),
+  bgWhite: esc(47, bgCloseCode),
+  bgWhiteBright: esc(107, bgCloseCode),
+  bgYellow: esc(43, bgCloseCode),
+  bgYellowBright: esc(103, bgCloseCode),
+  black: esc(30, closeCode),
+  blackBright: esc(90, closeCode),
+  blue: esc(34, closeCode),
+  blueBright: esc(94, closeCode),
+  cyan: esc(36, closeCode),
+  cyanBright: esc(96, closeCode),
+  gray: esc(90, closeCode),
+  // US spelling alias for blackBright
+  green: esc(32, closeCode),
+  greenBright: esc(92, closeCode),
+  grey: esc(90, closeCode),
+  // UK spelling alias for blackBright
+  magenta: esc(35, closeCode),
+  magentaBright: esc(95, closeCode),
+  red: esc(31, closeCode),
+  redBright: esc(91, closeCode),
+  white: esc(37, closeCode),
+  whiteBright: esc(97, closeCode),
+  yellow: esc(33, closeCode),
+  yellowBright: esc(93, closeCode)
+};
+const styleMethods = {
+  bg: (code) => createBgAnsi256(clamp(code, 0, 255)),
+  bgHex: createHexFunction(createBgRgb),
+  bgRgb: (r, g, b) => createBgRgb(clamp(r, 0, 255), clamp(g, 0, 255), clamp(b, 0, 255)),
+  fg: (code) => createAnsi256(clamp(code, 0, 255)),
+  hex: createHexFunction(createRgb),
+  rgb: (r, g, b) => createRgb(clamp(r, 0, 255), clamp(g, 0, 255), clamp(b, 0, 255))
+};
+
+const stringReplaceAll = (string_, searchValue, replaceValue) => {
+  if (searchValue === "") {
+    return string_;
+  }
+  let pos = string_.indexOf(searchValue);
+  if (pos < 0) {
+    return string_;
+  }
+  const substringLength = searchValue.length;
+  let lastPos = 0;
+  let result = "";
+  while (~pos) {
+    result += string_.slice(lastPos, pos) + replaceValue;
+    lastPos = pos + substringLength;
+    pos = string_.indexOf(searchValue, lastPos);
+  }
+  return result + string_.slice(lastPos);
+};
+
+const styles = {};
+let stylePrototype = null;
+const wrapText = (strings, values, properties) => {
+  if (!strings) {
+    return "";
+  }
+  let string = strings.raw == void 0 ? `${strings}` : String.raw(strings, ...values);
+  if (string.includes("\x1B")) {
+    for (let currentProperties = properties; currentProperties; currentProperties = currentProperties.props) {
+      string = stringReplaceAll(string, currentProperties.close, currentProperties.open);
+    }
+  }
+  if (string.includes("\n")) {
+    string = string.replace(/(\r*\n)/g, `${properties.closeStack}$1${properties.openStack}`);
+  }
+  return properties.openStack + string + properties.closeStack;
+};
+const createStyle = ({ props }, { close, open }) => {
+  const openStack = (props?.openStack ?? "") + open;
+  const closeStack = close + (props?.closeStack ?? "");
+  const style = (strings, ...values) => wrapText(strings, values, style.props);
+  Object.setPrototypeOf(style, stylePrototype);
+  style.props = { close, closeStack, open, openStack, props };
+  style.open = openStack;
+  style.close = closeStack;
+  return style;
+};
+const Colorize = function() {
+  const self = (string_) => `${string_}`;
+  self.strip = (value) => value.replaceAll(ansiRegex(), "");
+  for (const name in baseColors) {
+    styles[name] = {
+      get() {
+        const style = createStyle(this, baseColors[name]);
+        Object.defineProperty(this, name, { value: style });
+        return style;
+      }
+    };
+  }
+  for (const name in baseStyles) {
+    styles[name] = {
+      get() {
+        const style = createStyle(this, baseStyles[name]);
+        Object.defineProperty(this, name, { value: style });
+        return style;
+      }
+    };
+  }
+  stylePrototype = Object.defineProperties({}, styles);
+  Object.setPrototypeOf(self, stylePrototype);
+  return self;
+};
+for (const name in styleMethods) {
+  styles[name] = {
+    get() {
+      return (...arguments_) => (
+        // @ts-expect-error: TODO: fix typing of `arguments_`
+        createStyle(this, styleMethods[name](...arguments_))
+      );
+    }
+  };
+}
+styles.ansi256 = styles.fg;
+styles.bgAnsi256 = styles.bg;
+
+exports.Colorize = Colorize;