@lotics/xlsx 0.1.0

package/src/excel_cf_evaluate.ts

@@ -0,0 +1,719 @@
+import type {
+  ParsedConditionalFormat,
+  ParsedCfRule,
+  ParsedColorScaleRule,
+  ParsedDataBarRule,
+  ParsedIconSetRule,
+  ParsedStyleRule,
+  CfThreshold,
+  ParsedCfStyle,
+} from "./excel_cf_types";
+import { colLettersToNum } from "./excel_utils";
+import type { ParsedRow } from "./types";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface CfOverlay {
+  /** Background color override from color scale or style rule */
+  backgroundColor?: string;
+  /** Font color override from style rule */
+  fontColor?: string;
+  /** Font bold override from style rule */
+  fontBold?: boolean;
+  /** Font italic override from style rule */
+  fontItalic?: boolean;
+  /** Data bar: width as percentage 0-100 */
+  dataBarWidth?: number;
+  /** Data bar: color */
+  dataBarColor?: string;
+  /** Data bar: whether to show cell value */
+  dataBarShowValue?: boolean;
+  /** Icon set: SVG string */
+  iconSvg?: string;
+  /** Icon set: whether to show cell value */
+  iconShowValue?: boolean;
+}
+
+// =============================================================================
+// Evaluation
+// =============================================================================
+
+/**
+ * Evaluate all conditional formatting rules and build a map from "row:col" to overlay.
+ * Rules are evaluated by priority (lower = higher priority).
+ */
+export function evaluateConditionalFormats(
+  cfs: ParsedConditionalFormat[],
+  rows: ParsedRow[],
+  getIconSvg: (iconSet: string, index: number) => string | undefined,
+  evaluateFormula?: (formula: string, sheetName: string, row: number, col: number) => unknown,
+  date1904 = false,
+): Map<string, CfOverlay> {
+  const overlays = new Map<string, CfOverlay>();
+
+  // Build numeric values index for percentile/average calculations
+  const cellValues = buildCellValueIndex(rows);
+
+  for (const cf of cfs) {
+    const targetCells = parseRef(cf.ref, rows);
+    if (targetCells.length === 0) continue;
+
+    // Origin = top-left of CF range (for shifting relative formula references)
+    const origin = parseRefOrigin(cf.ref);
+
+    // Sort rules by priority (lower number = higher priority)
+    const sortedRules = [...cf.rules].sort((a, b) => a.priority - b.priority);
+
+    // Cells that hit a stopIfTrue rule are skipped by subsequent rules within
+    // the same conditional formatting block (matches Excel's behavior).
+    const stoppedCells = new Set<string>();
+
+    for (const rule of sortedRules) {
+      const visibleTargets = stoppedCells.size === 0
+        ? targetCells
+        : targetCells.filter((c) => !stoppedCells.has(c.key));
+      if (visibleTargets.length === 0) continue;
+
+      const matched = applyRule(rule, visibleTargets, cellValues, overlays, getIconSvg, evaluateFormula, date1904, origin);
+
+      if (rule.stopIfTrue) {
+        for (const key of matched) stoppedCells.add(key);
+      }
+    }
+  }
+
+  return overlays;
+}
+
+// =============================================================================
+// Rule application
+// =============================================================================
+
+function applyRule(
+  rule: ParsedCfRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+  overlays: Map<string, CfOverlay>,
+  getIconSvg: (iconSet: string, index: number) => string | undefined,
+  evaluateFormula?: (formula: string, sheetName: string, row: number, col: number) => unknown,
+  date1904 = false,
+  origin?: { row: number; col: number },
+): Set<string> {
+  switch (rule.ruleType) {
+    case "colorScale":
+      return applyColorScale(rule, targetCells, cellValues, overlays);
+    case "dataBar":
+      return applyDataBar(rule, targetCells, cellValues, overlays);
+    case "iconSet":
+      return applyIconSet(rule, targetCells, cellValues, overlays, getIconSvg);
+    case "style":
+      return applyStyleRule(rule, targetCells, cellValues, overlays, evaluateFormula, date1904, origin);
+  }
+}
+
+function minMax(values: number[]): { min: number; max: number } {
+  let min = values[0];
+  let max = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (values[i] < min) min = values[i];
+    if (values[i] > max) max = values[i];
+  }
+  return { min, max };
+}
+
+function applyColorScale(
+  rule: ParsedColorScaleRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+  overlays: Map<string, CfOverlay>,
+): Set<string> {
+  const matched = new Set<string>();
+  const numericCells = targetCells.filter((c) => cellValues.has(c.key));
+  if (numericCells.length === 0) return matched;
+
+  const values = numericCells.map((c) => cellValues.get(c.key)!);
+  const { min, max } = minMax(values);
+  if (min === max) return matched;
+
+  for (const cell of numericCells) {
+    const value = cellValues.get(cell.key)!;
+    const ratio = (value - min) / (max - min);
+    const color = interpolateColors(rule.colors, ratio);
+    const overlay = overlays.get(cell.key) ?? {};
+    overlay.backgroundColor = color;
+    overlays.set(cell.key, overlay);
+    matched.add(cell.key);
+  }
+  return matched;
+}
+
+function applyDataBar(
+  rule: ParsedDataBarRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+  overlays: Map<string, CfOverlay>,
+): Set<string> {
+  const matched = new Set<string>();
+  const numericCells = targetCells.filter((c) => cellValues.has(c.key));
+  if (numericCells.length === 0) return matched;
+
+  const values = numericCells.map((c) => cellValues.get(c.key)!);
+  const { min, max } = minMax(values);
+  const range = max - min;
+
+  for (const cell of numericCells) {
+    const value = cellValues.get(cell.key)!;
+    const ratio = range === 0 ? 0.5 : (value - min) / range;
+    const width = rule.minLength + ratio * (rule.maxLength - rule.minLength);
+    const overlay = overlays.get(cell.key) ?? {};
+    overlay.dataBarWidth = Math.max(0, Math.min(100, width));
+    overlay.dataBarColor = rule.color;
+    overlay.dataBarShowValue = rule.showValue;
+    overlays.set(cell.key, overlay);
+    matched.add(cell.key);
+  }
+  return matched;
+}
+
+function applyIconSet(
+  rule: ParsedIconSetRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+  overlays: Map<string, CfOverlay>,
+  getIconSvg: (iconSet: string, index: number) => string | undefined,
+): Set<string> {
+  const matched = new Set<string>();
+  const numericCells = targetCells.filter((c) => cellValues.has(c.key));
+  if (numericCells.length === 0) return matched;
+
+  const values = numericCells.map((c) => cellValues.get(c.key)!);
+  const { min, max } = minMax(values);
+  const range = max - min;
+
+  // Determine icon count from thresholds
+  const iconCount = rule.thresholds.length > 0 ? rule.thresholds.length : 3;
+
+  for (const cell of numericCells) {
+    const value = cellValues.get(cell.key)!;
+    const percentile = range === 0 ? 50 : ((value - min) / range) * 100;
+
+    let iconIndex = getIconIndex(percentile, rule.thresholds, iconCount);
+    if (rule.reverse) {
+      iconIndex = iconCount - 1 - iconIndex;
+    }
+
+    const svg = getIconSvg(rule.iconSet, iconIndex);
+    if (svg) {
+      const overlay = overlays.get(cell.key) ?? {};
+      overlay.iconSvg = svg;
+      overlay.iconShowValue = rule.showValue;
+      overlays.set(cell.key, overlay);
+      matched.add(cell.key);
+    }
+  }
+  return matched;
+}
+
+function applyStyleRule(
+  rule: ParsedStyleRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+  overlays: Map<string, CfOverlay>,
+  evaluateFormula?: (formula: string, sheetName: string, row: number, col: number) => unknown,
+  date1904 = false,
+  origin?: { row: number; col: number },
+): Set<string> {
+  const matched = new Set<string>();
+  if (!rule.style) return matched;
+
+  // Precompute threshold for top10/aboveAverage/duplicates to avoid O(n²)
+  let qualifyingSet: Set<string> | undefined;
+  if (rule.type === "top10") {
+    qualifyingSet = computeTop10Set(rule, targetCells, cellValues);
+  } else if (rule.type === "aboveAverage") {
+    qualifyingSet = computeAboveAverageSet(rule, targetCells, cellValues);
+  } else if (rule.operator === "duplicateValues") {
+    qualifyingSet = computeDuplicateSet(targetCells);
+  } else if (rule.operator === "uniqueValues") {
+    qualifyingSet = computeUniqueSet(targetCells);
+  }
+
+  for (const cell of targetCells) {
+    const matches = qualifyingSet
+      ? qualifyingSet.has(cell.key)
+      : evaluateStyleCondition(rule, cell, cellValues, evaluateFormula, date1904, origin);
+    if (matches) {
+      const overlay = overlays.get(cell.key) ?? {};
+      applyCfStyle(overlay, rule.style);
+      overlays.set(cell.key, overlay);
+      matched.add(cell.key);
+    }
+  }
+  return matched;
+}
+
+function evaluateStyleCondition(
+  rule: ParsedStyleRule,
+  cell: CellRef,
+  cellValues: Map<string, number>,
+  evaluateFormula?: (formula: string, sheetName: string, row: number, col: number) => unknown,
+  date1904 = false,
+  origin?: { row: number; col: number },
+): boolean {
+  switch (rule.type) {
+    case "cellIs":
+      return evaluateCellIs(rule, cell, cellValues);
+    case "containsText":
+      return evaluateContainsText(rule, cell);
+    case "expression":
+      return evaluateExpressionRule(rule, cell, evaluateFormula, origin);
+    case "timePeriod":
+      return evaluateTimePeriodRule(rule, cell, cellValues, date1904);
+    default:
+      return false;
+  }
+}
+
+function evaluateCellIs(
+  rule: ParsedStyleRule,
+  cell: CellRef,
+  cellValues: Map<string, number>,
+): boolean {
+  const cellValue = cellValues.get(cell.key);
+  if (cellValue === undefined || !rule.formulae || rule.formulae.length === 0) return false;
+
+  const threshold = Number(rule.formulae[0]);
+  if (isNaN(threshold)) return false;
+
+  switch (rule.operator) {
+    case "greaterThan": return cellValue > threshold;
+    case "greaterThanOrEqual": return cellValue >= threshold;
+    case "lessThan": return cellValue < threshold;
+    case "lessThanOrEqual": return cellValue <= threshold;
+    case "equal": return cellValue === threshold;
+    case "notEqual": return cellValue !== threshold;
+    case "between": {
+      if (rule.formulae.length < 2) return false;
+      const upper = Number(rule.formulae[1]);
+      if (isNaN(upper)) return false;
+      return cellValue >= threshold && cellValue <= upper;
+    }
+    case "notBetween": {
+      if (rule.formulae.length < 2) return false;
+      const upper = Number(rule.formulae[1]);
+      if (isNaN(upper)) return false;
+      return cellValue < threshold || cellValue > upper;
+    }
+    default: return false;
+  }
+}
+
+function evaluateContainsText(rule: ParsedStyleRule, cell: CellRef): boolean {
+  switch (rule.operator) {
+    case "containsBlanks":
+      return cell.text.trim() === "";
+    case "notContainsBlanks":
+      return cell.text.trim() !== "";
+    case "containsErrors":
+      return cell.text.startsWith("#");
+    case "notContainsErrors":
+      return !cell.text.startsWith("#");
+    case "beginsWith":
+      if (!rule.text) return false;
+      return cell.text.toLowerCase().startsWith(rule.text.toLowerCase());
+    case "endsWith":
+      if (!rule.text) return false;
+      return cell.text.toLowerCase().endsWith(rule.text.toLowerCase());
+    case "notContainsText":
+      if (!rule.text) return true;
+      return !cell.text.toLowerCase().includes(rule.text.toLowerCase());
+    case "containsText":
+    default:
+      if (!rule.text) return false;
+      return cell.text.toLowerCase().includes(rule.text.toLowerCase());
+  }
+}
+
+function evaluateExpressionRule(
+  rule: ParsedStyleRule,
+  cell: CellRef,
+  evaluateFormula?: (formula: string, sheetName: string, row: number, col: number) => unknown,
+  origin?: { row: number; col: number },
+): boolean {
+  if (!evaluateFormula || !rule.formulae || rule.formulae.length === 0) return false;
+  const baseFormula = String(rule.formulae[0]);
+  const dRow = origin ? cell.row - origin.row : 0;
+  const dCol = origin ? cell.col - origin.col : 0;
+  const formula = shiftFormulaRefs(baseFormula, dRow, dCol);
+  const result = evaluateFormula(formula, "", cell.row, cell.col);
+  return !!result && result !== 0;
+}
+
+/** Excel serial date to JS Date. Supports both 1900 (default) and 1904 (Mac) date systems. */
+export function excelSerialToDate(serial: number, date1904 = false): Date {
+  if (date1904) {
+    // 1904 system: day 0 = Jan 1, 1904. No leap year bug.
+    const ms = serial * 86400000;
+    return new Date(Date.UTC(1904, 0, 1) + ms);
+  }
+  // 1900 system: day 1 = Jan 1, 1900. Leap year bug: day 60 = Feb 29, 1900 (doesn't exist).
+  const adjusted = serial > 60 ? serial - 1 : serial;
+  const ms = (adjusted - 1) * 86400000;
+  return new Date(Date.UTC(1900, 0, 1) + ms);
+}
+
+function evaluateTimePeriodRule(
+  rule: ParsedStyleRule,
+  cell: CellRef,
+  cellValues: Map<string, number>,
+  date1904 = false,
+): boolean {
+  const serial = cellValues.get(cell.key);
+  if (serial === undefined || serial < 1) return false;
+
+  const cellDate = excelSerialToDate(serial, date1904);
+  const now = new Date();
+
+  switch (rule.timePeriod) {
+    case "today": {
+      return sameDay(cellDate, now);
+    }
+    case "yesterday": {
+      const yesterday = new Date(now);
+      yesterday.setDate(yesterday.getDate() - 1);
+      return sameDay(cellDate, yesterday);
+    }
+    case "tomorrow": {
+      const tomorrow = new Date(now);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      return sameDay(cellDate, tomorrow);
+    }
+    case "last7Days": {
+      const weekAgo = new Date(now);
+      weekAgo.setDate(weekAgo.getDate() - 7);
+      return cellDate >= weekAgo && cellDate <= now;
+    }
+    case "lastWeek": {
+      const startOfThisWeek = getStartOfWeek(now);
+      const startOfLastWeek = new Date(startOfThisWeek);
+      startOfLastWeek.setDate(startOfLastWeek.getDate() - 7);
+      return cellDate >= startOfLastWeek && cellDate < startOfThisWeek;
+    }
+    case "thisWeek": {
+      const startOfWeek = getStartOfWeek(now);
+      const endOfWeek = new Date(startOfWeek);
+      endOfWeek.setDate(endOfWeek.getDate() + 7);
+      return cellDate >= startOfWeek && cellDate < endOfWeek;
+    }
+    case "nextWeek": {
+      const startOfThisWeek = getStartOfWeek(now);
+      const startOfNextWeek = new Date(startOfThisWeek);
+      startOfNextWeek.setDate(startOfNextWeek.getDate() + 7);
+      const endOfNextWeek = new Date(startOfNextWeek);
+      endOfNextWeek.setDate(endOfNextWeek.getDate() + 7);
+      return cellDate >= startOfNextWeek && cellDate < endOfNextWeek;
+    }
+    case "lastMonth": {
+      const firstOfThisMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+      const firstOfLastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+      return cellDate >= firstOfLastMonth && cellDate < firstOfThisMonth;
+    }
+    case "thisMonth": {
+      return cellDate.getFullYear() === now.getFullYear() && cellDate.getMonth() === now.getMonth();
+    }
+    case "nextMonth": {
+      const nextMonth = now.getMonth() + 1;
+      const nextYear = nextMonth > 11 ? now.getFullYear() + 1 : now.getFullYear();
+      return cellDate.getFullYear() === nextYear && cellDate.getMonth() === (nextMonth % 12);
+    }
+    default:
+      return false;
+  }
+}
+
+function sameDay(a: Date, b: Date): boolean {
+  return a.getFullYear() === b.getFullYear() &&
+    a.getMonth() === b.getMonth() &&
+    a.getDate() === b.getDate();
+}
+
+function getStartOfWeek(d: Date): Date {
+  const day = d.getDay();
+  const diff = d.getDate() - day;
+  return new Date(d.getFullYear(), d.getMonth(), diff);
+}
+
+function computeTop10Set(
+  rule: ParsedStyleRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+): Set<string> {
+  const result = new Set<string>();
+  const numericCells = targetCells.filter((c) => cellValues.has(c.key));
+  if (numericCells.length === 0) return result;
+
+  const rank = rule.rank ?? 10;
+  let count = rule.percent ? Math.ceil((rank / 100) * numericCells.length) : rank;
+  count = Math.max(1, Math.min(count, numericCells.length));
+
+  const sorted = [...numericCells].sort((a, b) => {
+    const va = cellValues.get(a.key)!;
+    const vb = cellValues.get(b.key)!;
+    return rule.bottom ? va - vb : vb - va;
+  });
+
+  const threshold = cellValues.get(sorted[count - 1].key)!;
+  for (const cell of numericCells) {
+    const v = cellValues.get(cell.key)!;
+    if (rule.bottom ? v <= threshold : v >= threshold) {
+      result.add(cell.key);
+    }
+  }
+  return result;
+}
+
+function computeAboveAverageSet(
+  rule: ParsedStyleRule,
+  targetCells: CellRef[],
+  cellValues: Map<string, number>,
+): Set<string> {
+  const result = new Set<string>();
+  const numericCells = targetCells.filter((c) => cellValues.has(c.key));
+  if (numericCells.length === 0) return result;
+
+  let sum = 0;
+  for (const cell of numericCells) {
+    sum += cellValues.get(cell.key)!;
+  }
+  const average = sum / numericCells.length;
+
+  for (const cell of numericCells) {
+    const v = cellValues.get(cell.key)!;
+    if (rule.aboveAverage !== false ? v > average : v < average) {
+      result.add(cell.key);
+    }
+  }
+  return result;
+}
+
+function computeDuplicateSet(targetCells: CellRef[]): Set<string> {
+  const result = new Set<string>();
+  const valueCounts = new Map<string, string[]>();
+  for (const cell of targetCells) {
+    const val = cell.text.toLowerCase();
+    if (val === "") continue;
+    const keys = valueCounts.get(val) ?? [];
+    keys.push(cell.key);
+    valueCounts.set(val, keys);
+  }
+  for (const keys of valueCounts.values()) {
+    if (keys.length > 1) {
+      for (const k of keys) result.add(k);
+    }
+  }
+  return result;
+}
+
+function computeUniqueSet(targetCells: CellRef[]): Set<string> {
+  const result = new Set<string>();
+  const valueCounts = new Map<string, string[]>();
+  for (const cell of targetCells) {
+    const val = cell.text.toLowerCase();
+    if (val === "") continue;
+    const keys = valueCounts.get(val) ?? [];
+    keys.push(cell.key);
+    valueCounts.set(val, keys);
+  }
+  for (const keys of valueCounts.values()) {
+    if (keys.length === 1) result.add(keys[0]);
+  }
+  return result;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+interface CellRef {
+  key: string;
+  row: number;
+  col: number;
+  text: string;
+}
+
+/** Extract the top-left cell of a CF ref range (e.g., "C5:C7" → { row: 5, col: 3 }). */
+function parseRefOrigin(ref: string): { row: number; col: number } | undefined {
+  const first = ref.split(/\s+/)[0];
+  const m = first.match(/^([A-Z]+)(\d+)/);
+  if (!m) return undefined;
+  return { row: parseInt(m[2], 10), col: colLettersToNum(m[1]) };
+}
+
+/**
+ * Shift relative cell references in a formula by dRow/dCol.
+ * $-prefixed components (absolute) are not shifted.
+ */
+function shiftFormulaRefs(formula: string, dRow: number, dCol: number): string {
+  if (dRow === 0 && dCol === 0) return formula;
+  return formula.replace(/(\$?)([A-Z]+)(\$?)(\d+)/g, (_, dollarCol, colLetters, dollarRow, rowStr) => {
+    const newRow = dollarRow ? rowStr : String(parseInt(rowStr, 10) + dRow);
+    const newCol = dollarCol ? colLetters : shiftColumnLetters(colLetters, dCol);
+    return `${dollarCol}${newCol}${dollarRow}${newRow}`;
+  });
+}
+
+function shiftColumnLetters(letters: string, dCol: number): string {
+  if (dCol === 0) return letters;
+  let colNum = colLettersToNum(letters);
+  colNum += dCol;
+  if (colNum < 1) colNum = 1;
+  let result = "";
+  let n = colNum;
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(65 + (n % 26)) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+}
+
+function parseRef(ref: string, rows: ParsedRow[]): CellRef[] {
+  const cells: CellRef[] = [];
+
+  // ref can be a range like "A1:C10" or multiple ranges separated by spaces
+  const ranges = ref.split(/\s+/);
+  for (const range of ranges) {
+    const match = range.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/);
+    if (!match) continue;
+
+    const startCol = colLettersToNum(match[1]);
+    const startRow = parseInt(match[2], 10);
+    const endCol = colLettersToNum(match[3]);
+    const endRow = parseInt(match[4], 10);
+
+    for (const row of rows) {
+      if (row.index < startRow || row.index > endRow) continue;
+      for (const cell of row.cells) {
+        if (cell.column < startCol || cell.column > endCol) continue;
+        cells.push({
+          key: `${row.index}:${cell.column}`,
+          row: row.index,
+          col: cell.column,
+          text: cell.value,
+        });
+      }
+    }
+  }
+
+  return cells;
+}
+
+function buildCellValueIndex(rows: ParsedRow[]): Map<string, number> {
+  const index = new Map<string, number>();
+  for (const row of rows) {
+    for (const cell of row.cells) {
+      if (cell.rawValue !== undefined) {
+        index.set(`${row.index}:${cell.column}`, cell.rawValue);
+      } else {
+        const num = parseFloat(cell.value);
+        if (!isNaN(num) && isFinite(num)) {
+          index.set(`${row.index}:${cell.column}`, num);
+        }
+      }
+    }
+  }
+  return index;
+}
+
+function getIconIndex(
+  percentile: number,
+  thresholds: CfThreshold[],
+  iconCount: number,
+): number {
+  // Default thresholds for common icon counts
+  if (thresholds.length === 0) {
+    if (iconCount === 3) {
+      if (percentile >= 67) return 2;
+      if (percentile >= 33) return 1;
+      return 0;
+    }
+    if (iconCount === 4) {
+      if (percentile >= 75) return 3;
+      if (percentile >= 50) return 2;
+      if (percentile >= 25) return 1;
+      return 0;
+    }
+    if (iconCount === 5) {
+      if (percentile >= 80) return 4;
+      if (percentile >= 60) return 3;
+      if (percentile >= 40) return 2;
+      if (percentile >= 20) return 1;
+      return 0;
+    }
+    return 0;
+  }
+
+  // Use explicit thresholds
+  for (let i = thresholds.length - 1; i >= 0; i--) {
+    const t = thresholds[i];
+    const value = t.value ?? 0;
+    if (t.type === "percent" || t.type === "percentile") {
+      if (percentile >= value) return i;
+    } else if (t.type === "num") {
+      if (percentile >= value) return i;
+    }
+  }
+
+  return 0;
+}
+
+function interpolateColors(colors: string[], ratio: number): string {
+  if (colors.length < 2) return colors[0] ?? "#FFFFFF";
+
+  const segments = colors.length - 1;
+  const segmentRatio = ratio * segments;
+  const segmentIndex = Math.min(Math.floor(segmentRatio), segments - 1);
+  const localRatio = segmentRatio - segmentIndex;
+
+  const color1 = parseRgb(colors[segmentIndex]);
+  const color2 = parseRgb(colors[segmentIndex + 1]);
+
+  const r = Math.round(color1.r + (color2.r - color1.r) * localRatio);
+  const g = Math.round(color1.g + (color2.g - color1.g) * localRatio);
+  const b = Math.round(color1.b + (color2.b - color1.b) * localRatio);
+
+  return `#${toHex2(r)}${toHex2(g)}${toHex2(b)}`;
+}
+
+function toHex2(n: number): string {
+  return Math.max(0, Math.min(255, n)).toString(16).padStart(2, "0").toUpperCase();
+}
+
+function parseRgb(color: string): { r: number; g: number; b: number } {
+  const rgbMatch = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (rgbMatch) {
+    return {
+      r: parseInt(rgbMatch[1], 10),
+      g: parseInt(rgbMatch[2], 10),
+      b: parseInt(rgbMatch[3], 10),
+    };
+  }
+  const hexMatch = color.match(/^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})/);
+  if (hexMatch) {
+    return {
+      r: parseInt(hexMatch[1], 16),
+      g: parseInt(hexMatch[2], 16),
+      b: parseInt(hexMatch[3], 16),
+    };
+  }
+  return { r: 0, g: 0, b: 0 };
+}
+
+function applyCfStyle(overlay: CfOverlay, style: ParsedCfStyle): void {
+  if (style.backgroundColor) overlay.backgroundColor = style.backgroundColor;
+  if (style.fontColor) overlay.fontColor = style.fontColor;
+  if (style.fontBold) overlay.fontBold = true;
+  if (style.fontItalic) overlay.fontItalic = true;
+}