@visulima/colorize 2.0.0-alpha.10 → 2.0.0-alpha.12

package/dist/packem_shared/GradientBuilder-DRrwebdU.cjs

@@ -1,487 +0,0 @@
-'use strict';
-
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-
-const convertHexToRgb = require('./convertHexToRgb-51-edHxE.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 += 1) {
-    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 - 2; n >= 0; n -= 1) {
-    totalSubsteps += substeps[n];
-  }
-  while (totalSubsteps !== steps) {
-    if (totalSubsteps < steps) {
-      const min = Math.min(...substeps);
-      const minIndex = substeps.indexOf(min);
-      substeps[minIndex] = substeps[minIndex] + 1;
-      totalSubsteps += 1;
-    } else {
-      const max = Math.max(...substeps);
-      const maxIndex = substeps.indexOf(max);
-      substeps[maxIndex] = substeps[maxIndex] - 1;
-      totalSubsteps -= 1;
-    }
-  }
-  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.hasOwn(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.hasOwn(start, k)) {
-      let value = step[k] * index + start[k];
-      if (value < 0) {
-        value += max[k];
-      } else if (max[k] !== 1) {
-        value %= max[k];
-      }
-      color[k] = value;
-    }
-  }
-  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 += 1) {
-    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 += 1) {
-    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" in stopInput.color && "g" in stopInput.color && "b" in stopInput.color) {
-            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);
-    }
-    const firstStop = this.stops[0];
-    if (firstStop.position !== 0) {
-      this.stops.unshift({
-        color: firstStop.color,
-        position: 0
-      });
-      l += 1;
-    }
-    const lastStop = this.stops[l - 1];
-    if (lastStop.position !== 1) {
-      this.stops.push({
-        color: lastStop.color,
-        position: 1
-      });
-    }
-  }
-  reverse() {
-    const stops = [];
-    for (const stop of this.stops) {
-      const reversedStop = { ...stop, position: 1 - stop.position };
-      stops.push(reversedStop);
-    }
-    return new GradientBuilder(this.#colorize, stops.toReversed());
-  }
-  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.toReversed()]);
-  }
-  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 += 1) {
-      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 += 1) {
-      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-CwTmhs0e.cjs

@@ -1,198 +0,0 @@
-'use strict';
-
-const isAnsiColorSupported = require('@visulima/is-ansi-color-supported');
-const convertHexToRgb = require('./convertHexToRgb-51-edHxE.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) => {
-  if (min > number_) {
-    return min;
-  }
-  return 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[${String(close)}m`, open: `\x1B[${String(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;${String(code)}`, closeCode);
-let createBgAnsi256 = (code) => esc(`48;5;${String(code)}`, bgCloseCode);
-let createRgb = (r, g, b) => esc(`38;2;${String(r)};${String(g)};${String(b)}`, closeCode);
-let createBgRgb = (r, g, b) => esc(`48;2;${String(r)};${String(g)};${String(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 ? String(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(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;