@reliverse/relico 1.3.0 → 1.3.1

package/bin/mod.js

@@ -1,455 +0,0 @@
-const ESC = "\x1B[";
-const RESET = `${ESC}0m`;
-const OP_SYMBOL = Symbol("re.ops");
-let CURRENT_LEVEL = 3;
-export const setColorLevel = (level) => {
-  if (level !== 0 && level !== 1 && level !== 2 && level !== 3) {
-    throw new Error("Invalid color level");
-  }
-  CURRENT_LEVEL = level;
-};
-const clampByte = (n) => {
-  if (!Number.isFinite(n)) return 0;
-  if (n < 0) return 0;
-  if (n > 255) return 255;
-  return Math.round(n);
-};
-const clampPct = (n) => {
-  if (!Number.isFinite(n)) return 0;
-  if (n < 0) return 0;
-  if (n > 100) return 100;
-  return n;
-};
-const hexRe = /^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{6})$/;
-const hexToRgb = (hex2) => {
-  const len = hex2.length;
-  const start = hex2[0] === "#" ? 1 : 0;
-  const raw = hex2.slice(start);
-  const rawLen = raw.length;
-  if (rawLen !== 3 && rawLen !== 6) return null;
-  for (let i = 0; i < rawLen; i++) {
-    const c = raw.charCodeAt(i);
-    if (!(c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102)) {
-      return null;
-    }
-  }
-  if (rawLen === 3) {
-    const r = parseInt(raw[0] + raw[0], 16);
-    const g = parseInt(raw[1] + raw[1], 16);
-    const b = parseInt(raw[2] + raw[2], 16);
-    return { r, g, b };
-  }
-  return {
-    r: parseInt(raw.slice(0, 2), 16),
-    g: parseInt(raw.slice(2, 4), 16),
-    b: parseInt(raw.slice(4, 6), 16)
-  };
-};
-const hslToRgb = (h, s, l) => {
-  const H = (h % 360 + 360) % 360;
-  const S = Math.min(100, Math.max(0, s)) / 100;
-  const L = Math.min(100, Math.max(0, l)) / 100;
-  if (S === 0) {
-    const v = Math.round(L * 255);
-    return { r: v, g: v, b: v };
-  }
-  const c = (1 - Math.abs(2 * L - 1)) * S;
-  const x = c * (1 - Math.abs(H / 60 % 2 - 1));
-  const m = L - c / 2;
-  const sector = Math.floor(H / 60) % 6;
-  const rgbValues = [
-    [c, x, 0],
-    [x, c, 0],
-    [0, c, x],
-    [0, x, c],
-    [x, 0, c],
-    [c, 0, x]
-  ][sector];
-  return {
-    r: Math.round((rgbValues[0] + m) * 255),
-    g: Math.round((rgbValues[1] + m) * 255),
-    b: Math.round((rgbValues[2] + m) * 255)
-  };
-};
-const BASIC8 = [
-  { r: 0, g: 0, b: 0 },
-  // black
-  { r: 205, g: 0, b: 0 },
-  // red
-  { r: 0, g: 205, b: 0 },
-  // green
-  { r: 205, g: 205, b: 0 },
-  // yellow
-  { r: 0, g: 0, b: 238 },
-  // blue
-  { r: 205, g: 0, b: 205 },
-  // magenta
-  { r: 0, g: 205, b: 205 },
-  // cyan
-  { r: 229, g: 229, b: 229 }
-  // white (light gray)
-];
-const sgr = (codes) => `${ESC}${codes.join(";")}m`;
-const nearestBasicIndex = (rgb2) => {
-  let best = 0;
-  let bestDist = Number.POSITIVE_INFINITY;
-  for (let i = 0; i < BASIC8.length; i++) {
-    const c = BASIC8[i];
-    const dr = c.r - rgb2.r;
-    const dg = c.g - rgb2.g;
-    const db = c.b - rgb2.b;
-    const d = dr * dr + dg * dg + db * db;
-    if (d < bestDist) {
-      bestDist = d;
-      best = i;
-    }
-  }
-  return best;
-};
-const rgbToAnsi256 = (rgb2) => {
-  if (rgb2.r === rgb2.g && rgb2.g === rgb2.b) {
-    if (rgb2.r < 8) return 16;
-    if (rgb2.r > 248) return 231;
-    const step = Math.round((rgb2.r - 8) / 247 * 24);
-    return 232 + step;
-  }
-  const r = Math.round(rgb2.r / 255 * 5);
-  const g = Math.round(rgb2.g / 255 * 5);
-  const b = Math.round(rgb2.b / 255 * 5);
-  return 16 + 36 * r + 6 * g + b;
-};
-const CORE_COLORS = {
-  black: "#000000",
-  red: "#ff0000",
-  green: "#00ff00",
-  yellow: "#ffff00",
-  blue: "#0000ff",
-  magenta: "#ff00ff",
-  cyan: "#00ffff",
-  white: "#ffffff",
-  gray: "#808080"
-};
-const EXTENDED_COLORS = {
-  orange: "#ffa500",
-  pink: "#ffc0cb",
-  purple: "#800080",
-  teal: "#008080",
-  lime: "#00ff00",
-  brown: "#a52a2a",
-  navy: "#000080",
-  maroon: "#800000",
-  olive: "#808000",
-  silver: "#c0c0c0"
-};
-let NAMED_HEX;
-const getNamedColors = () => {
-  if (NAMED_HEX) return NAMED_HEX;
-  NAMED_HEX = { ...CORE_COLORS, ...EXTENDED_COLORS };
-  return NAMED_HEX;
-};
-let GRAYS;
-const getGrayColors = () => {
-  if (GRAYS) return GRAYS;
-  GRAYS = {};
-  for (let i = 1; i <= 9; i++) {
-    const value = Math.round(26 * i - 10);
-    const hex2 = value.toString(16).padStart(2, "0");
-    const key = `gray${i}0`;
-    GRAYS[key] = `#${hex2}${hex2}${hex2}`;
-  }
-  return GRAYS;
-};
-const mixWithWhite = (rgb2, factor) => {
-  const t = factor;
-  return {
-    r: clampByte(rgb2.r * (1 - t) + 255 * t),
-    g: clampByte(rgb2.g * (1 - t) + 255 * t),
-    b: clampByte(rgb2.b * (1 - t) + 255 * t)
-  };
-};
-const fromNamed = (name) => {
-  const hex2 = getNamedColors()[name];
-  const rgb2 = hexToRgb(hex2);
-  return rgb2 ?? { r: 255, g: 255, b: 255 };
-};
-const fromGrayName = (name) => {
-  const hex2 = getGrayColors()[name];
-  const rgb2 = hexToRgb(hex2);
-  return rgb2 ?? { r: 128, g: 128, b: 128 };
-};
-const toBaseName = (compound) => {
-  const base = compound.replace(/(Bright|Pastel)$/u, "");
-  const key = base.charAt(0).toLowerCase() + base.slice(1);
-  return key;
-};
-const parseColorName = (name) => {
-  if (name.endsWith("Bright")) {
-    const base = toBaseName(name);
-    const rgb2 = fromNamed(base);
-    const rgbAdj = mixWithWhite(rgb2, 0.25);
-    return { rgb: rgbAdj, wantBright: true };
-  }
-  if (name.endsWith("Pastel")) {
-    const base = toBaseName(name);
-    const rgb2 = fromNamed(base);
-    const rgbAdj = mixWithWhite(rgb2, 0.6);
-    return { rgb: rgbAdj, wantBright: false };
-  }
-  if (name.startsWith("gray")) {
-    return { rgb: fromGrayName(name), wantBright: false };
-  }
-  return { rgb: fromNamed(name), wantBright: false };
-};
-const openForOp = (op) => {
-  if (CURRENT_LEVEL === 0) return "";
-  switch (op.kind) {
-    case "style":
-      return sgr(op.open);
-    case "fg-basic":
-      return sgr([(op.bright ? 90 : 30) + op.idx]);
-    case "bg-basic":
-      return sgr([(op.bright ? 100 : 40) + op.idx]);
-    case "fg-256":
-      return `${ESC}38;5;${op.code}m`;
-    case "bg-256":
-      return `${ESC}48;5;${op.code}m`;
-    case "fg-true":
-      return `${ESC}38;2;${op.rgb.r};${op.rgb.g};${op.rgb.b}m`;
-    case "bg-true":
-      return `${ESC}48;2;${op.rgb.r};${op.rgb.g};${op.rgb.b}m`;
-  }
-};
-const opsToOpen = (ops) => {
-  if (CURRENT_LEVEL === 0) return "";
-  let out = "";
-  for (const op of ops) out += openForOp(op);
-  return out;
-};
-const applyOpsToText = (ops, input) => {
-  const text = String(input);
-  if (CURRENT_LEVEL === 0 || ops.length === 0 || text.length === 0) return text;
-  const open = opsToOpen(ops);
-  if (!text.includes("\n")) {
-    return `${open}${text}${RESET}`;
-  }
-  const lines = text.split("\n");
-  const result = new Array(lines.length);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.endsWith("\r")) {
-      result[i] = `${open}${line.slice(0, -1)}\r${RESET}`;
-    } else {
-      result[i] = `${open}${line}${RESET}`;
-    }
-  }
-  return result.join("\n");
-};
-const mkFgOpsFromRgb = (rgb2, wantBright = false) => {
-  if (CURRENT_LEVEL === 1) {
-    const idx = nearestBasicIndex(rgb2);
-    return [{ kind: "fg-basic", idx, bright: wantBright }];
-  }
-  if (CURRENT_LEVEL === 2) {
-    return [{ kind: "fg-256", code: rgbToAnsi256(rgb2) }];
-  }
-  return [{ kind: "fg-true", rgb: rgb2 }];
-};
-const mkBgOpsFromRgb = (rgb2, wantBright = false) => {
-  if (CURRENT_LEVEL === 1) {
-    const idx = nearestBasicIndex(rgb2);
-    return [{ kind: "bg-basic", idx, bright: wantBright }];
-  }
-  if (CURRENT_LEVEL === 2) {
-    return [{ kind: "bg-256", code: rgbToAnsi256(rgb2) }];
-  }
-  return [{ kind: "bg-true", rgb: rgb2 }];
-};
-const STYLE_TABLE = {
-  reset: { kind: "style", open: [0] },
-  bold: { kind: "style", open: [1] },
-  dim: { kind: "style", open: [2] },
-  italic: { kind: "style", open: [3] },
-  underline: { kind: "style", open: [4] },
-  inverse: { kind: "style", open: [7] },
-  hidden: { kind: "style", open: [8] },
-  strikethrough: { kind: "style", open: [9] }
-};
-const STYLE_KEYS = /* @__PURE__ */ new Set([
-  "reset",
-  "bold",
-  "dim",
-  "italic",
-  "underline",
-  "inverse",
-  "hidden",
-  "strikethrough"
-]);
-const DYNAMIC_KEYS = /* @__PURE__ */ new Set(["rgb", "hex", "hsl", "bgRgb", "bgHex", "bgHsl"]);
-let COLOR_KEY_CACHE;
-let BG_KEY_CACHE;
-const getColorKeys = () => {
-  if (COLOR_KEY_CACHE) return COLOR_KEY_CACHE;
-  const baseColors = [
-    "black",
-    "red",
-    "green",
-    "yellow",
-    "blue",
-    "magenta",
-    "cyan",
-    "white",
-    "gray"
-  ];
-  const extendedColors = [
-    "orange",
-    "pink",
-    "purple",
-    "teal",
-    "lime",
-    "brown",
-    "navy",
-    "maroon",
-    "olive",
-    "silver"
-  ];
-  const grayNames = Array.from({ length: 9 }, (_, i) => `gray${(i + 1) * 10}`);
-  COLOR_KEY_CACHE = /* @__PURE__ */ new Set([
-    ...baseColors,
-    ...extendedColors,
-    ...grayNames,
-    ...baseColors.map((c) => `${c}Bright`),
-    ...extendedColors.map((c) => `${c}Bright`),
-    ...baseColors.map((c) => `${c}Pastel`),
-    ...extendedColors.map((c) => `${c}Pastel`),
-    "grayPastel"
-  ]);
-  return COLOR_KEY_CACHE;
-};
-const getBgKeys = () => {
-  if (BG_KEY_CACHE) return BG_KEY_CACHE;
-  BG_KEY_CACHE = /* @__PURE__ */ new Set();
-  for (const colorKey of getColorKeys()) {
-    const capitalizedKey = colorKey.charAt(0).toUpperCase() + colorKey.slice(1);
-    BG_KEY_CACHE.add(`bg${capitalizedKey}`);
-  }
-  return BG_KEY_CACHE;
-};
-const callableFromOps = (ops) => {
-  const fn = ((input) => applyOpsToText(ops, input));
-  Object.defineProperty(fn, OP_SYMBOL, {
-    value: ops,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return fn;
-};
-const appendOps = (base, extra) => {
-  const out = [];
-  for (const op of base) out.push(op);
-  for (const op of extra) out.push(op);
-  return out;
-};
-const mkRgbMethod = (ops, isBg) => (r, g, b) => {
-  const rgb2 = { r: clampByte(r), g: clampByte(g), b: clampByte(b) };
-  const add = isBg ? mkBgOpsFromRgb(rgb2) : mkFgOpsFromRgb(rgb2);
-  return callableProxy(appendOps(ops, add));
-};
-const mkHexMethod = (ops, isBg) => (hex2) => {
-  const rgb2 = hexToRgb(hex2);
-  if (!rgb2) return callableProxy(ops);
-  const add = isBg ? mkBgOpsFromRgb(rgb2) : mkFgOpsFromRgb(rgb2);
-  return callableProxy(appendOps(ops, add));
-};
-const mkHslMethod = (ops, isBg) => (h, s, l) => {
-  const rgb2 = hslToRgb(h, s, l);
-  const add = isBg ? mkBgOpsFromRgb(rgb2) : mkFgOpsFromRgb(rgb2);
-  return callableProxy(appendOps(ops, add));
-};
-const callableProxy = (ops) => {
-  const base = callableFromOps(ops);
-  return new Proxy(base, {
-    apply(_target, _thisArg, argArray) {
-      const [input] = argArray;
-      return applyOpsToText(ops, input);
-    },
-    get(_target, prop) {
-      const key = String(prop);
-      if (prop === OP_SYMBOL) return ops;
-      if (STYLE_KEYS.has(key)) {
-        const op = STYLE_TABLE[key];
-        return callableProxy(appendOps(ops, [op]));
-      }
-      if (DYNAMIC_KEYS.has(key)) {
-        const isBg = key.startsWith("bg");
-        switch (key) {
-          case "rgb":
-            return mkRgbMethod(ops, false);
-          case "hex":
-            return mkHexMethod(ops, false);
-          case "hsl":
-            return mkHslMethod(ops, false);
-          case "bgRgb":
-            return mkRgbMethod(ops, true);
-          case "bgHex":
-            return mkHexMethod(ops, true);
-          case "bgHsl":
-            return mkHslMethod(ops, true);
-        }
-      }
-      const bgKeys = getBgKeys();
-      const colorKeys = getColorKeys();
-      if (bgKeys.has(key)) {
-        const raw = key.slice(2);
-        const colorName = raw.charAt(0).toLowerCase() + raw.slice(1);
-        const { rgb: rgb2, wantBright } = parseColorName(colorName);
-        return callableProxy(appendOps(ops, mkBgOpsFromRgb(rgb2, wantBright)));
-      }
-      if (colorKeys.has(key)) {
-        const { rgb: rgb2, wantBright } = parseColorName(key);
-        return callableProxy(appendOps(ops, mkFgOpsFromRgb(rgb2, wantBright)));
-      }
-      return callableProxy(ops);
-    }
-  });
-};
-export const re = callableProxy([]);
-export const rgb = (r, g, b) => re.rgb(r, g, b);
-export const hex = (h) => re.hex(h);
-export const hsl = (h, s, l) => re.hsl(h, s, l);
-export const bgRgb = (r, g, b) => re.bgRgb(r, g, b);
-export const bgHex = (h) => re.bgHex(h);
-export const bgHsl = (h, s, l) => re.bgHsl(h, s, l);
-export const chain = (...parts) => {
-  const collected = [];
-  for (const p of parts) {
-    const ops = p[OP_SYMBOL];
-    if (ops && ops.length > 0) {
-      for (const op of ops) collected.push(op);
-    }
-  }
-  return callableProxy(collected);
-};
-export const parseRgb = (value) => {
-  const v = value.trim();
-  if (!v.toLowerCase().startsWith("rgb(") || !v.endsWith(")")) return null;
-  const inner = v.slice(4, -1);
-  const parts = inner.split(",").map((s) => s.trim());
-  if (parts.length !== 3) return null;
-  const nums = parts.map((p) => Number.parseInt(p, 10));
-  if (!Number.isFinite(nums[0]) || !Number.isFinite(nums[1]) || !Number.isFinite(nums[2]))
-    return null;
-  return { r: clampByte(nums[0]), g: clampByte(nums[1]), b: clampByte(nums[2]) };
-};
-export const parseHsl = (value) => {
-  const v = value.trim().toLowerCase();
-  if (!v.startsWith("hsl(") || !v.endsWith(")")) return null;
-  const inner = v.slice(4, -1);
-  const parts = inner.split(",").map((s2) => s2.trim().replace(/%$/u, ""));
-  if (parts.length !== 3) return null;
-  const h = Number.parseFloat(parts[0]);
-  const s = Number.parseFloat(parts[1]);
-  const l = Number.parseFloat(parts[2]);
-  if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(l)) return null;
-  return { h, s, l };
-};