matterviz 0.3.6 → 0.3.7

package/dist/src/lib/phase-diagram/utils.ts

@@ -1,775 +0,0 @@
-import { add_alpha } from '$lib/colors'
-import { format_num } from '$lib/labels'
-import { point_in_polygon, type Vec2 } from '$lib/math'
-import type { Sides } from '$lib/plot/layout'
-import { line } from 'd3-shape'
-import type {
-  CompUnit,
-  LeverRuleMode,
-  LeverRuleResult,
-  PhaseDiagramConfig,
-  PhaseDiagramData,
-  PhaseHoverInfo,
-  PhaseRegion,
-  TempUnit,
-  VerticalLeverRuleResult,
-} from './types'
-
-// Convert temperature between units (K, °C, °F)
-export function convert_temp(value: number, from: TempUnit, to: TempUnit): number {
-  if (from === to) return value
-  // Convert to Kelvin first
-  const kelvin =
-    from === `°C` ? value + 273.15 : from === `°F` ? (value - 32) * (5 / 9) + 273.15 : value
-  // Convert from Kelvin to target
-  return to === `K` ? kelvin : to === `°C` ? kelvin - 273.15 : (kelvin - 273.15) * (9 / 5) + 32
-}
-
-// Centralized defaults for phase diagram configuration (single source of truth)
-export const PHASE_DIAGRAM_DEFAULTS = Object.freeze({
-  // Visibility
-  show_boundaries: true,
-  show_labels: true,
-  show_special_points: true,
-  show_grid: true,
-  show_component_labels: true,
-  // Appearance
-  font_size: 12,
-  special_point_radius: 5,
-  // Axes
-  x_ticks: 5,
-  y_ticks: 6,
-  // Tie-line
-  tie_line: Object.freeze({
-    stroke_width: 1.5,
-    endpoint_radius: 4,
-    cursor_radius: 5,
-  }),
-  // Colors
-  colors: Object.freeze({
-    background: `transparent`,
-    grid: `rgba(128, 128, 128, 0.3)`,
-    axis: `var(--text-color, #333)`,
-    text: `var(--text-color, #333)`,
-    boundary: `#333`,
-    special_point: `#d32f2f`,
-  }),
-  // Margins
-  margin: Object.freeze({ t: 25, r: 25, b: 50, l: 60 } as Required<Sides>),
-  // Export
-  png_dpi: 150,
-})
-
-// Merge partial config with defaults - single helper for consistent merging
-export function merge_phase_diagram_config(config: Partial<PhaseDiagramConfig>) {
-  return {
-    margin: { ...PHASE_DIAGRAM_DEFAULTS.margin, ...config.margin },
-    font_size: config.font_size ?? PHASE_DIAGRAM_DEFAULTS.font_size,
-    special_point_radius:
-      config.special_point_radius ?? PHASE_DIAGRAM_DEFAULTS.special_point_radius,
-    tie_line: { ...PHASE_DIAGRAM_DEFAULTS.tie_line, ...config.tie_line },
-    colors: { ...PHASE_DIAGRAM_DEFAULTS.colors, ...config.colors },
-  }
-}
-
-// Phase colors as hex - single source of truth
-// Extended palette supports 3+ phase regions (Greek letters α through λ)
-export const PHASE_COLOR_HEX = {
-  liquid: `#87cefc`, // light sky blue
-  alpha: `#90ee90`, // light green
-  beta: `#ffb6c1`, // light pink
-  gamma: `#ffdab9`, // peach puff
-  delta: `#dda0dd`, // plum
-  epsilon: `#f0e68c`, // khaki
-  zeta: `#fa8072`, // salmon (distinct from liquid's light blue)
-  eta: `#e6e6fa`, // lavender (distinct from alpha's light green)
-  theta: `#f5deb3`, // wheat
-  iota: `#20b2aa`, // light sea green
-  kappa: `#deb887`, // burlywood
-  lambda: `#bc8f8f`, // rosy brown
-  two_phase: `#c8c8c8`,
-  default: `#b4b4b4`,
-  tie_line: `#ff6b6b`,
-} as const
-
-export type PhaseColorKey = keyof typeof PHASE_COLOR_HEX
-
-// Derive RGB string format (e.g. "135, 206, 250") for custom alpha usage
-export const PHASE_COLOR_RGB = Object.freeze(
-  Object.fromEntries(
-    Object.entries(PHASE_COLOR_HEX).map(([key, hex]) => {
-      const red = parseInt(hex.slice(1, 3), 16)
-      const green = parseInt(hex.slice(3, 5), 16)
-      const blue = parseInt(hex.slice(5, 7), 16)
-      return [key, `${red}, ${green}, ${blue}`]
-    }),
-  ),
-) as Record<PhaseColorKey, string>
-
-// Derive rgba() format with default alpha using add_alpha
-const PHASE_ALPHA = { two_phase: 0.5, default: 0.5, tie_line: 1 } as const
-export const PHASE_COLORS = Object.freeze(
-  Object.fromEntries(
-    Object.entries(PHASE_COLOR_HEX).map(([key, hex]) => [
-      key,
-      add_alpha(hex, key in PHASE_ALPHA ? PHASE_ALPHA[key as keyof typeof PHASE_ALPHA] : 0.6),
-    ]),
-  ),
-) as Record<PhaseColorKey, string>
-
-// Phase pattern matching rules: [substrings to match, color key, optional prefix check]
-// Order matters: theta before eta (since "theta" contains "eta" as substring)
-const PHASE_PATTERNS: [string[], PhaseColorKey, string?][] = [
-  [[`liquid`], `liquid`],
-  [[`α`, `alpha`], `alpha`, `fcc`],
-  [[`β`, `beta`], `beta`, `bcc`],
-  [[`γ`, `gamma`], `gamma`, `hcp`],
-  [[`δ`, `delta`], `delta`],
-  [[`ε`, `epsilon`], `epsilon`],
-  [[`ζ`, `zeta`], `zeta`],
-  [[`θ`, `theta`], `theta`], // must come before eta
-  [[`η`, `eta`], `eta`],
-  [[`ι`, `iota`], `iota`],
-  [[`κ`, `kappa`], `kappa`],
-  [[`λ`, `lambda`], `lambda`],
-]
-
-// Get color key for a single phase name (supports Greek letters and common phase notation)
-export function get_phase_color_key(name: string): PhaseColorKey {
-  const lower = name.toLowerCase().trim()
-  if (lower === `l`) return `liquid` // exact match for shorthand "L"
-  for (const [patterns, key, prefix] of PHASE_PATTERNS) {
-    if (patterns.some((pattern) => lower.includes(pattern))) return key
-    if (prefix && lower.startsWith(prefix)) return key
-  }
-  return `default`
-}
-
-// Get phase color - returns rgba() by default, or RGB string if format='rgb'
-export function get_phase_color(name: string, format: `rgba` | `rgb` = `rgba`): string {
-  const lower = name.toLowerCase().trim()
-  const key: PhaseColorKey = lower.includes(`+`) ? `two_phase` : get_phase_color_key(name)
-  return format === `rgb` ? PHASE_COLOR_RGB[key] : PHASE_COLORS[key]
-}
-
-// Gradient stop for multi-phase region gradients
-export interface GradientStop {
-  offset: number // 0-1 range
-  color: string // hex color
-}
-
-// Get gradient colors for multi-phase regions (2+ phases separated by '+')
-// Returns array of evenly-spaced gradient stops, or null for single-phase regions
-export function get_multi_phase_gradient(name: string): GradientStop[] | null {
-  if (!name.includes(`+`)) return null
-  const phases = name
-    .split(`+`)
-    .map((phase) => phase.trim())
-    .filter(Boolean)
-  if (phases.length < 2) return null
-
-  // Create evenly spaced gradient stops (phases.length >= 2 guaranteed by early return)
-  return phases.map((phase, idx) => ({
-    offset: idx / (phases.length - 1),
-    color: PHASE_COLOR_HEX[get_phase_color_key(phase)],
-  }))
-}
-
-// Find which phase region contains the given composition and temperature
-export function find_phase_at_point(
-  composition: number,
-  temperature: number,
-  data: PhaseDiagramData,
-): PhaseRegion | null {
-  // Search regions in reverse order so later-defined regions take precedence
-  for (let idx = data.regions.length - 1; idx >= 0; idx--) {
-    const region = data.regions[idx]
-    if (point_in_polygon(composition, temperature, region.vertices)) {
-      return region
-    }
-  }
-  return null
-}
-
-// SVG path generator using d3-shape
-const path_line = line()
-  .x((point) => point[0])
-  .y((point) => point[1])
-
-// Generate closed SVG path for polygon regions (min 3 points)
-export const generate_region_path = (vertices: Vec2[]): string =>
-  vertices.length < 3 ? `` : `${path_line(vertices)} Z`
-
-// Generate open SVG path for boundary curves (min 2 points)
-export const generate_boundary_path = (points: Vec2[]): string =>
-  points.length < 2 ? `` : (path_line(points) ?? ``)
-
-// Compute label properties (rotation, wrapping, scale) to fit within region bounds
-export function compute_label_properties(
-  label: string,
-  bounds: { width: number; height: number },
-  font_size: number,
-): { rotation: number; lines: string[]; scale: number } {
-  if (bounds.width <= 0 || bounds.height <= 0 || !label || font_size <= 0) {
-    return { rotation: 0, lines: label ? [label] : [], scale: 1 }
-  }
-  // Handle whitespace-only labels that pass truthy check but have zero rendered width
-  if (label.trim().length === 0) return { rotation: 0, lines: [], scale: 1 }
-
-  const char_width = font_size * 0.6 // approximate character width
-  const line_height = font_size * 1.2
-  const padding = 0.8 // 20% margin
-
-  const label_width = label.length * char_width
-  const avail_w = bounds.width * padding
-  const avail_h = bounds.height * padding
-
-  // Try horizontal fit
-  if (label_width <= avail_w && line_height <= avail_h) {
-    return { rotation: 0, lines: [label], scale: 1 }
-  }
-
-  // Try vertical for tall narrow regions
-  const is_tall = bounds.width < bounds.height
-  if (is_tall && label_width <= avail_h && line_height <= avail_w) {
-    return { rotation: -90, lines: [label], scale: 1 }
-  }
-
-  // Try wrapping multi-word labels
-  if (/[\s_-]/.test(label)) {
-    const chars_per_line = Math.max(3, Math.floor(avail_w / char_width))
-    const lines = wrap_text(label, chars_per_line)
-    const wrapped_w = Math.max(...lines.map((ln) => ln.length)) * char_width
-    const wrapped_h = lines.length * line_height
-
-    if (wrapped_w <= avail_w && wrapped_h <= avail_h) {
-      return { rotation: 0, lines, scale: 1 }
-    }
-    if (is_tall && wrapped_w <= avail_h && wrapped_h <= avail_w) {
-      return { rotation: -90, lines, scale: 1 }
-    }
-  }
-
-  // Scale down as last resort (min 70%)
-  const scale = Math.max(0.7, Math.min(avail_w / label_width, avail_h / line_height, 1))
-  const rotation = is_tall ? -90 : 0
-  return { rotation, lines: [label], scale }
-}
-
-// Wrap text into multiple lines at delimiter boundaries
-function wrap_text(text: string, max_chars: number): string[] {
-  const words = text.split(/[_\s-]+/).filter((word) => word.length > 0)
-  if (words.length === 0) return [text]
-
-  const lines: string[] = []
-  let current_line = ``
-
-  for (const word of words) {
-    const candidate = current_line ? `${current_line} ${word}` : word
-    if (candidate.length <= max_chars) {
-      current_line = candidate
-    } else {
-      if (current_line) lines.push(current_line)
-      current_line = word
-    }
-  }
-
-  if (current_line) lines.push(current_line)
-  return lines
-}
-
-// Transform data coordinates to SVG coordinates using scale functions
-export const transform_vertices = (
-  vertices: Vec2[],
-  x_scale: (val: number) => number,
-  y_scale: (val: number) => number,
-): Vec2[] => vertices.map(([comp, temp]) => [x_scale(comp), y_scale(temp)])
-
-// Format composition value for display
-export function format_composition(
-  value: number,
-  unit: CompUnit = `at%`,
-  include_unit: boolean = true,
-): string {
-  if (unit === `fraction`) return format_num(value, `.3~f`)
-  const formatted = format_num(value * 100, `.3~`)
-  return include_unit ? `${formatted} ${unit}` : formatted
-}
-
-// Format temperature value for display
-export function format_temperature(value: number, unit: TempUnit = `K`): string {
-  return `${format_num(value, `.0f`)} ${unit}`
-}
-
-// Parse a two-phase region name into its two phase names
-// Returns null if the region is not exactly a two-phase region
-function parse_two_phases(name: string): [string, string] | null {
-  if (!name.includes(`+`)) return null
-  const parts = name
-    .trim()
-    .split(/\s*\+\s*/)
-    .filter(Boolean)
-  return parts.length === 2 ? [parts[0], parts[1]] : null
-}
-
-// Find polygon edge intersections along a scan line (horizontal or vertical)
-// For horizontal: fixed_val = temperature, returns x-intersections
-// For vertical: fixed_val = composition, returns y-intersections
-function find_polygon_intersections(
-  vertices: Vec2[],
-  fixed_val: number,
-  axis: 0 | 1,
-): number[] {
-  const other = axis === 0 ? 1 : 0
-  const intersections: number[] = []
-  for (let idx = 0; idx < vertices.length; idx++) {
-    const v1 = vertices[idx]
-    const v2 = vertices[(idx + 1) % vertices.length]
-    if (
-      (v1[axis] <= fixed_val && v2[axis] > fixed_val) ||
-      (v2[axis] <= fixed_val && v1[axis] > fixed_val)
-    ) {
-      intersections.push(
-        v1[other] + ((fixed_val - v1[axis]) / (v2[axis] - v1[axis])) * (v2[other] - v1[other]),
-      )
-    }
-  }
-  return intersections.toSorted((a, b) => a - b)
-}
-
-function pick_bracketing_intersection_pair(
-  intersections: number[],
-  position: number,
-): [number, number] | null {
-  if (intersections.length < 2) return null
-
-  const unique_intersections: number[] = []
-  const dedup_tol = 1e-9
-  for (const value of intersections) {
-    const prev_value = unique_intersections.at(-1)
-    if (prev_value === undefined || Math.abs(value - prev_value) > dedup_tol) {
-      unique_intersections.push(value)
-    }
-  }
-  if (unique_intersections.length < 2) return null
-
-  const bound_tol = 1e-10
-  for (let pair_idx = 0; pair_idx + 1 < unique_intersections.length; pair_idx += 2) {
-    const low_bound = unique_intersections[pair_idx]
-    const high_bound = unique_intersections[pair_idx + 1]
-    if (position >= low_bound - bound_tol && position <= high_bound + bound_tol) {
-      return [low_bound, high_bound]
-    }
-  }
-
-  // Fallback for numerical edge cases where even-odd pairing fails:
-  // pick nearest enclosing neighbors around the hovered point.
-  let left_idx = -1
-  for (let idx = 0; idx < unique_intersections.length; idx++) {
-    if (unique_intersections[idx] <= position + bound_tol) left_idx = idx
-  }
-  if (left_idx < 0 || left_idx + 1 >= unique_intersections.length) return null
-
-  const left_bound = unique_intersections[left_idx]
-  const right_bound = unique_intersections[left_idx + 1]
-  return right_bound - left_bound > bound_tol ? [left_bound, right_bound] : null
-}
-
-// Shared core for lever rule calculations (horizontal and vertical)
-// Parses phases, finds intersections along the scan axis, validates bounds,
-// and computes the fractional position within the two-phase region.
-function lever_rule_core(
-  region: PhaseRegion,
-  position: number,
-  scan_val: number,
-  axis: 0 | 1,
-): { phases: [string, string]; lo: number; hi: number; fraction_hi: number } | null {
-  const phases = parse_two_phases(region.name)
-  if (!phases) return null
-
-  const intersections = find_polygon_intersections(region.vertices, scan_val, axis)
-  const bounds = pick_bracketing_intersection_pair(intersections, position)
-  if (!bounds) return null
-  const [lo, hi] = bounds
-
-  const span = hi - lo
-  if (span < 1e-10) return null
-
-  return { phases, lo, hi, fraction_hi: (position - lo) / span }
-}
-
-// Calculate lever rule for a point in a two-phase region
-// Returns null if the region is not exactly a two-phase region or calculation fails
-// Note: Lever rule is thermodynamically defined only for two-phase equilibria
-export function calculate_lever_rule(
-  region: PhaseRegion,
-  composition: number,
-  temperature: number,
-): LeverRuleResult | null {
-  // Horizontal scan: fixed temperature, find composition intersections
-  const core = lever_rule_core(region, composition, temperature, 1)
-  if (!core) return null
-
-  return {
-    left_phase: core.phases[0],
-    right_phase: core.phases[1],
-    left_composition: core.lo,
-    right_composition: core.hi,
-    fraction_left: 1 - core.fraction_hi,
-    fraction_right: core.fraction_hi,
-  }
-}
-
-// Calculate vertical lever rule for a point in a two-phase region
-// Uses constant composition (vertical line) to find temperature boundaries
-export function calculate_vertical_lever_rule(
-  region: PhaseRegion,
-  composition: number,
-  temperature: number,
-): VerticalLeverRuleResult | null {
-  // Vertical scan: fixed composition, find temperature intersections
-  const core = lever_rule_core(region, temperature, composition, 0)
-  if (!core) return null
-
-  return {
-    bottom_phase: core.phases[0],
-    top_phase: core.phases[1],
-    bottom_temperature: core.lo,
-    top_temperature: core.hi,
-    fraction_bottom: 1 - core.fraction_hi,
-    fraction_top: core.fraction_hi,
-  }
-}
-
-// Format hover info as copyable text for clipboard
-// Only includes lever rule data for the active mode to match tooltip display
-export function format_hover_info_text(
-  info: PhaseHoverInfo,
-  temp_unit: TempUnit = `K`,
-  comp_unit: CompUnit = `at%`,
-  component_a: string = `A`,
-  component_b: string = `B`,
-  data_temp_unit: TempUnit = temp_unit,
-  lever_rule_mode: LeverRuleMode = `horizontal`,
-): string {
-  // Convert temperature from data unit to display unit
-  const to_display = (temp: number) => convert_temp(temp, data_temp_unit, temp_unit)
-
-  const lines: string[] = [
-    `Phase: ${info.region.name}`,
-    `Temperature: ${format_temperature(to_display(info.temperature), temp_unit)}`,
-    `Composition: ${format_composition(info.composition, comp_unit)} ${component_b} (${format_composition(
-      1 - info.composition,
-      comp_unit,
-    )} ${component_a})`,
-  ]
-
-  if (lever_rule_mode === `horizontal` && info.lever_rule) {
-    const lr = info.lever_rule
-    lines.push(
-      ``,
-      `Lever Rule:`,
-      `  ${lr.left_phase}: ${format_num(lr.fraction_left * 100, `.1f`)}% (at ${format_composition(
-        lr.left_composition,
-        comp_unit,
-      )})`,
-      `  ${lr.right_phase}: ${format_num(lr.fraction_right * 100, `.1f`)}% (at ${format_composition(
-        lr.right_composition,
-        comp_unit,
-      )})`,
-    )
-  }
-
-  if (lever_rule_mode === `vertical` && info.vertical_lever_rule) {
-    const vlr = info.vertical_lever_rule
-    lines.push(
-      ``,
-      `Vertical Lever Rule:`,
-      `  ${vlr.bottom_phase}: ${format_num(vlr.fraction_bottom * 100, `.1f`)}% (at ${format_temperature(
-        to_display(vlr.bottom_temperature),
-        temp_unit,
-      )})`,
-      `  ${vlr.top_phase}: ${format_num(vlr.fraction_top * 100, `.1f`)}% (at ${format_temperature(
-        to_display(vlr.top_temperature),
-        temp_unit,
-      )})`,
-    )
-  }
-
-  return lines.join(`\n`)
-}
-
-// Calculate temperature stability range for a phase at given composition
-export function get_phase_stability_range(
-  region: PhaseRegion,
-): { t_min: number; t_max: number } | null {
-  if (!region.vertices?.length) return null
-  let t_min = Infinity
-  let t_max = -Infinity
-  for (const [, temp] of region.vertices) {
-    if (temp < t_min) t_min = temp
-    if (temp > t_max) t_max = temp
-  }
-  return { t_min, t_max }
-}
-
-// Extract reference/citation from TDB comments
-export function extract_tdb_reference(comments: string[]): string | null {
-  const ref_keywords = [`reference`, `citation`, `database`, `assessed by`]
-  for (const comment of comments) {
-    const lower = comment.toLowerCase()
-    if (ref_keywords.some((kw) => lower.includes(kw))) {
-      const ref = comment.replace(/^\$\s*/, ``).trim()
-      // Skip incomplete references (must have substantial content after keyword)
-      if (ref.length > 30 && !ref.endsWith(`from`)) return ref
-    }
-  }
-  return null
-}
-
-// Summarize sublattice models from TDB phases
-export function summarize_models(
-  phases: { sublattice_count: number; sublattice_sites: number[] }[],
-): string {
-  const counts = new Map<number, number>()
-  for (const phase of phases) {
-    counts.set(phase.sublattice_count, (counts.get(phase.sublattice_count) ?? 0) + 1)
-  }
-  return [...counts.entries()]
-    .toSorted(([sl_a], [sl_b]) => sl_a - sl_b)
-    .map(([sublattices, count]) => `${count}×${sublattices}-SL`)
-    .join(`, `)
-}
-
-// Chemical Formula Parsing Utilities (for pseudo-binary phase diagrams)
-
-// Token from formula tokenization - can be text, subscript, or superscript
-export interface FormulaToken {
-  text?: string
-  sub?: string
-  sup?: string
-}
-
-// Check if a component name is a compound (vs single element)
-// Returns true if name contains digits (e.g., "Fe3C", "SiO2") or multiple uppercase letters
-// that indicate multiple elements (e.g., "MgO", "CaO")
-// Single elements like "Fe", "Ca", "He" return false
-export function is_compound(name: string): boolean {
-  if (!name) return false
-  // Contains digits -> likely a compound (Fe3C, SiO2, Al2O3)
-  if (/\d/.test(name)) return true
-  // Single element pattern: one uppercase followed by optional lowercase (Fe, Ca, He, C)
-  if (/^[A-Z][a-z]?$/.test(name)) return false
-  return (name.match(/[A-Z]/g)?.length ?? 0) >= 2
-}
-
-// Tokenize a chemical formula for rendering with subscripts/superscripts
-// Examples:
-//   "Fe3C" -> [{text: "Fe"}, {sub: "3"}, {text: "C"}]
-//   "SiO2" -> [{text: "Si"}, {text: "O"}, {sub: "2"}]
-//   "Al2O3" -> [{text: "Al"}, {sub: "2"}, {text: "O"}, {sub: "3"}]
-//   "Fe" -> [{text: "Fe"}]
-//   "α-Fe" -> [{text: "α-Fe"}] (Greek phases pass through unchanged)
-export function tokenize_formula(formula: string): FormulaToken[] {
-  if (!formula) return []
-
-  // If it contains Greek letters or special phase notation, return as-is
-  if (/[α-ωΑ-Ω]/.test(formula) || formula.includes(`+`)) {
-    return [{ text: formula }]
-  }
-
-  const tokens: FormulaToken[] = []
-  let idx = 0
-
-  while (idx < formula.length) {
-    const char = formula[idx]
-
-    // Check for subscript digits (numbers following letters)
-    if (/\d/.test(char)) {
-      // Collect consecutive digits
-      let num = ``
-      while (idx < formula.length && /\d/.test(formula[idx])) {
-        num += formula[idx]
-        idx++
-      }
-      tokens.push({ sub: num })
-      continue
-    }
-
-    // Check for superscript (- charge notation, e.g., "O2-" or "Cl-2")
-    // Note: + is handled by the early return for phase notation like "α + β"
-    // Treat '-' as charge when: at end of string, OR followed by digit
-    // Otherwise preserve as text for hyphenated names like "Fe-Fe3C"
-    if (char === `-`) {
-      idx++
-      if (idx >= formula.length || /\d/.test(formula[idx])) {
-        // End of string or followed by digit - parse as charge superscript
-        let charge = `-`
-        while (idx < formula.length && /\d/.test(formula[idx])) {
-          charge += formula[idx]
-          idx++
-        }
-        tokens.push({ sup: charge })
-      } else tokens.push({ text: `-` }) // Not at end and not followed by digit - preserve hyphen
-      continue
-    }
-
-    // Check for element symbol (uppercase followed by optional lowercase)
-    if (/[A-Z]/.test(char)) {
-      let element = char
-      idx++
-      // Collect following lowercase letters
-      while (idx < formula.length && /[a-z]/.test(formula[idx])) {
-        element += formula[idx]
-        idx++
-      }
-      tokens.push({ text: element })
-      continue
-    }
-
-    // Any other character (lowercase, hyphen, etc.) - collect as text
-    let text = char
-    idx++
-    while (idx < formula.length && !/[A-Z\d-]/.test(formula[idx])) {
-      text += formula[idx]
-      idx++
-    }
-    // Merge with previous text token if possible
-    if (tokens.length > 0 && tokens[tokens.length - 1].text !== undefined) {
-      tokens[tokens.length - 1].text += text
-    } else {
-      tokens.push({ text })
-    }
-  }
-
-  return tokens
-}
-
-// Baseline shifts for sub/superscript (SVG dy values are cumulative across tspans)
-const DY = { sub: 0.25, sup: -0.4 } as const
-
-// Format chemical formula as SVG tspan elements with subscripts
-// Tracks cumulative baseline offset and adds trailing reset so concatenated text aligns
-export function format_formula_svg(formula: string, use_subscripts = true): string {
-  if (!use_subscripts || !is_compound(formula)) return formula
-
-  let result = ``
-  let offset = 0
-
-  for (const token of tokenize_formula(formula)) {
-    if (token.text !== undefined) {
-      result += offset ? `<tspan dy="${-offset}em">${token.text}</tspan>` : token.text
-      offset = 0
-    } else {
-      const dy = token.sub !== undefined ? DY.sub : DY.sup
-      result += `<tspan dy="${dy}em" font-size="0.75em">${token.sub ?? token.sup}</tspan>`
-      offset += dy
-    }
-  }
-
-  // Reset baseline after trailing subscript/superscript using a zero-width space
-  // (empty tspans may not apply dy in all SVG renderers)
-  if (offset) result += `<tspan dy="${-offset}em">\u200B</tspan>`
-  return result
-}
-
-// Split a multi-phase label on " + " and format each part with the given formatter
-function format_label_parts(
-  label: string,
-  use_subscripts: boolean,
-  formatter: (formula: string, use_sub: boolean) => string,
-): string {
-  if (!use_subscripts) return label
-  return label
-    .split(/(\s*\+\s*)/)
-    .map((part) => {
-      if (part.trim() === `+`) return part
-      return formatter(part.trim(), use_subscripts)
-    })
-    .join(``)
-}
-
-// Format a phase region label (e.g. "La2NiO4 + NiO") as SVG with subscripts
-export const format_label_svg = (label: string, use_subscripts = true): string =>
-  format_label_parts(label, use_subscripts, format_formula_svg)
-
-// Format a phase region label as HTML with subscripts (splits on " + ")
-export const format_label_html = (label: string, use_subscripts = true): string =>
-  format_label_parts(label, use_subscripts, format_formula_html)
-
-// Format chemical formula as HTML with <sub> and <sup> tags
-export function format_formula_html(formula: string, use_subscripts = true): string {
-  if (!use_subscripts || !is_compound(formula)) return formula
-
-  return tokenize_formula(formula)
-    .map(
-      (token) =>
-        token.text ?? (token.sub ? `<sub>${token.sub}</sub>` : `<sup>${token.sup}</sup>`),
-    )
-    .join(``)
-}
-
-// Compute the x-axis domain for a binary phase diagram.
-// Uses explicit range if fully specified, otherwise derives from data extent
-// and auto-extends to 0/1 when edge regions contain pure components.
-export function compute_x_domain(
-  x_range: [number | null, number | null] | undefined,
-  data: PhaseDiagramData | null,
-): Vec2 {
-  const lo = x_range?.[0]
-  const hi = x_range?.[1]
-  if (lo != null && hi != null) return [lo, hi]
-
-  if (data) {
-    let data_min = Infinity
-    let data_max = -Infinity
-    const update = (val: number) => {
-      if (val < data_min) data_min = val
-      if (val > data_max) data_max = val
-    }
-    for (const region of data.regions) {
-      for (const vertex of region.vertices) update(vertex[0])
-    }
-    for (const boundary of data.boundaries) {
-      for (const point of boundary.points) update(point[0])
-    }
-    for (const special_point of data.special_points ?? []) {
-      update(special_point.position[0])
-    }
-
-    if (data_min <= data_max) {
-      let x_min = lo ?? data_min
-      let x_max = hi ?? data_max
-
-      // Auto-extend to 0/1 when edge regions contain a pure component AND the
-      // data already nearly reaches the boundary
-      const comp_at_edge = (comp: string, x_val: number) => {
-        const re = new RegExp(`\\b${comp.replaceAll(/[.*+?^${}()|[\]\\]/g, `\\$&`)}\\b`)
-        return data.regions.some(
-          (region) =>
-            re.test(region.name) &&
-            region.vertices.some((vertex) => Math.abs(vertex[0] - x_val) < 1e-6),
-        )
-      }
-      if (
-        lo == null &&
-        x_min < 0.05 &&
-        data.components[0] &&
-        comp_at_edge(data.components[0], x_min)
-      ) {
-        x_min = 0
-      }
-      if (
-        hi == null &&
-        x_max > 0.95 &&
-        data.components[1] &&
-        comp_at_edge(data.components[1], x_max)
-      ) {
-        x_max = 1
-      }
-
-      return [x_min, x_max]
-    }
-  }
-  return [lo ?? 0, hi ?? 1]
-}