matterviz 0.3.6 → 0.3.7

package/dist/src/lib/composition/parse.ts

@@ -1,605 +0,0 @@
-import type { ElementSymbol } from '$lib/element'
-import type { CompositionType } from '$lib/composition'
-import { element_data } from '$lib/element'
-import { ELEM_SYMBOLS } from '$lib/labels'
-
-// Create symbol/number/mass/electronegativity lookup maps for O(1) access
-export const ATOMIC_NUMBER_TO_SYMBOL: Record<number, ElementSymbol> = {}
-export const SYMBOL_TO_ATOMIC_NUMBER: Partial<CompositionType> = {}
-export const ATOMIC_WEIGHTS = new Map<ElementSymbol, number>()
-export const ELEMENT_ELECTRONEGATIVITY_MAP = new Map<ElementSymbol, number>()
-export const ELEM_NAME_TO_SYMBOL: Record<string, ElementSymbol> = {}
-export const ELEM_SYMBOL_TO_NAME: Partial<Record<ElementSymbol, string>> = {}
-
-// Populate maps at module load time
-for (const element of element_data) {
-  ATOMIC_NUMBER_TO_SYMBOL[element.number] = element.symbol
-  SYMBOL_TO_ATOMIC_NUMBER[element.symbol] = element.number
-  ATOMIC_WEIGHTS.set(element.symbol, element.atomic_mass)
-  ELEMENT_ELECTRONEGATIVITY_MAP.set(element.symbol, element.electronegativity ?? 0)
-  ELEM_NAME_TO_SYMBOL[element.name] = element.symbol
-  ELEM_SYMBOL_TO_NAME[element.symbol] = element.name
-}
-
-// Type guard: check if a string is a valid element symbol
-export const is_valid_element = (sym: string): sym is ElementSymbol =>
-  (ELEM_SYMBOLS as readonly string[]).includes(sym)
-
-// Check if object has atomic numbers as keys (1-118)
-const is_atomic_number_composition = (obj: Record<string | number, number>): boolean => {
-  const keys = Object.keys(obj)
-  const atomic_nums = keys.map(Number)
-  return (
-    keys.length > 0 &&
-    atomic_nums.every(
-      (atomic_num) =>
-        Number.isInteger(atomic_num) && Object.hasOwn(ATOMIC_NUMBER_TO_SYMBOL, atomic_num),
-    )
-  )
-}
-
-const format_state = (state: number) => (state > 0 ? `+` : ``) + state
-const parse_count = (count?: string): number => (count ? parseFloat(count) : 1)
-const format_count = (count: number): string => {
-  if (!Number.isFinite(count)) return `${count}`
-  return Number(count.toPrecision(12)).toLocaleString(`en-US`, {
-    maximumSignificantDigits: 12,
-    useGrouping: false,
-  })
-}
-
-// Convert atomic numbers to element symbols
-export const atomic_num_to_symbols = (
-  atomic_composition: Record<number, number>,
-): CompositionType => {
-  const composition: CompositionType = {}
-  for (const [atomic_num_str, amount] of Object.entries(atomic_composition)) {
-    const symbol = ATOMIC_NUMBER_TO_SYMBOL[Number(atomic_num_str)]
-    if (!symbol) throw new Error(`Invalid atomic number: ${atomic_num_str}`)
-    if (amount > 0) composition[symbol] = (composition[symbol] ?? 0) + amount
-  }
-  return composition
-}
-
-// Convert element symbols to atomic numbers
-export const atomic_symbol_to_num = (
-  symbol_composition: CompositionType,
-): Record<number, number> => {
-  const atomic_composition: Record<number, number> = {}
-  for (const [symbol, amount] of Object.entries(symbol_composition)) {
-    if (!is_valid_element(symbol)) throw new Error(`Invalid element symbol: ${symbol}`)
-    const atomic_num = SYMBOL_TO_ATOMIC_NUMBER[symbol]
-    if (!atomic_num) throw new Error(`Invalid element symbol: ${symbol}`)
-    if (amount > 0) {
-      atomic_composition[atomic_num] = (atomic_composition[atomic_num] || 0) + amount
-    }
-  }
-  return atomic_composition
-}
-
-// Expand parentheses in chemical formulas
-const expand_parentheses = (formula: string): string => {
-  while (formula.includes(`(`)) {
-    formula = formula.replace(
-      /\(([^()]+)\)(\d+(?:\.\d+)?|\.\d+)?/g,
-      (_match, group, multiplier) => {
-        const mult = parse_count(multiplier)
-        return group.replace(
-          /([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g,
-          (_m: string, element: string, count: string) => {
-            const count_str = format_count(parse_count(count) * mult)
-            return element + (count_str === `1` ? `` : count_str)
-          },
-        )
-      },
-    )
-  }
-  return formula
-}
-
-// Parse chemical formula string into composition object
-export const parse_formula = (formula: string): CompositionType => {
-  const composition: CompositionType = {}
-  const cleaned_formula = expand_parentheses(formula.replace(/\s/g, ``))
-
-  for (const match of cleaned_formula.matchAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g)) {
-    const element = match[1]
-    const count = parse_count(match[2])
-
-    if (!is_valid_element(element)) throw new Error(`Invalid element symbol: ${element}`)
-    composition[element] = (composition[element] ?? 0) + count
-  }
-  return composition
-}
-
-// Normalize composition to positive numbers only
-export const normalize_composition = (
-  composition: CompositionType | Record<number, number> | Record<string | number, number>,
-): CompositionType => {
-  if (is_atomic_number_composition(composition)) {
-    return normalize_composition(atomic_num_to_symbols(composition as Record<number, number>))
-  }
-
-  const normalized: CompositionType = {}
-  for (const [element, amount] of Object.entries(composition)) {
-    if (typeof amount === `number` && amount > 0 && is_valid_element(element)) {
-      normalized[element] = amount
-    }
-  }
-  return normalized
-}
-
-// Sanitize composition keys by extracting valid element symbols.
-// Handles malformed keys like "B0.", "Fe2+", "Fe[2+]", "Ca^2+" by extracting
-// the element symbol portion. Merges amounts for keys that map to the same element.
-// Returns null if no valid elements can be extracted.
-// NOTE: Only extracts the FIRST valid element from each key. Keys with multiple
-// elements (e.g. "CO3", "Fe2O3") will lose stoichiometry - use parse_formula for those.
-export const sanitize_composition_keys = (
-  composition: Record<string, number>,
-): CompositionType | null => {
-  const sanitized: Record<string, number> = {}
-  for (const [key, amount] of Object.entries(composition)) {
-    if (typeof amount !== `number` || amount <= 0) continue
-    // Extract first valid element symbol from key (e.g. "B0." -> "B", "Fe2+" -> "Fe")
-    const elem = (key.match(/[A-Z][a-z]?/g) ?? []).find(is_valid_element)
-    if (elem) sanitized[elem] = (sanitized[elem] || 0) + amount
-  }
-  const result = normalize_composition(sanitized)
-  return Object.keys(result).length > 0 ? result : null
-}
-
-// Get total number of atoms
-export const count_atoms_in_composition = (composition: CompositionType): number =>
-  Object.values(composition).reduce((sum, count) => sum + (count ?? 0), 0)
-
-export const fractional_composition = (
-  composition: CompositionType,
-  by_weight = false,
-): CompositionType => {
-  // Filter out zero/negative amounts for both branches
-  const filtered = Object.fromEntries(
-    Object.entries(composition).filter(([, amount]) => amount > 0),
-  )
-
-  if (by_weight) {
-    const element_weights = Object.fromEntries(
-      Object.entries(filtered).map(([element, amount]) => {
-        if (!is_valid_element(element)) throw new Error(`Unknown element: ${element}`)
-        const atomic_mass = ATOMIC_WEIGHTS.get(element)
-        if (!atomic_mass) throw new Error(`Unknown element: ${element}`)
-        return [element, amount * atomic_mass]
-      }),
-    )
-
-    const total_weight = Object.values(element_weights).reduce((sum, wt) => sum + wt, 0)
-    if (total_weight === 0) return {}
-
-    return Object.fromEntries(
-      Object.entries(element_weights).map(([element, weight]) => [
-        element,
-        weight / total_weight,
-      ]),
-    )
-  }
-
-  const total = count_atoms_in_composition(filtered)
-  if (total === 0) return {}
-
-  return Object.fromEntries(
-    Object.entries(filtered).map(([element, amount]) => [element, amount / total]),
-  )
-}
-
-// Parse composition from various input types
-export const parse_composition = (
-  input: string | CompositionType | Record<number, number> | Record<string | number, number>,
-): CompositionType => {
-  if (typeof input === `string`) {
-    if (input.trim().startsWith(`{`) && input.trim().endsWith(`}`)) {
-      try {
-        return normalize_composition(JSON.parse(input))
-      } catch {
-        // Fall through to formula parsing
-      }
-    }
-    return normalize_composition(parse_formula(input))
-  }
-  return normalize_composition(input)
-}
-
-// Calculate GCD of two numbers
-const gcd = (num_a: number, num_b: number): number =>
-  num_b === 0 ? num_a : gcd(num_b, num_a % num_b)
-
-// Get reduced formula by dividing all amounts by their GCD
-// Example: Fe2O4 -> FeO2, H4O2 -> H2O
-export const get_reduced_formula = (composition: CompositionType): CompositionType => {
-  const amounts = Object.values(composition).filter((amt) => amt > 0)
-  if (amounts.length === 0) return {}
-  // Find GCD of all amounts (works with integers; for floats, find approximate GCD)
-  const all_integers = amounts.every((amt) => Number.isInteger(amt))
-  if (!all_integers) return composition // Can't reduce non-integer compositions
-  const divisor = amounts.reduce((acc, amt) => gcd(acc, amt))
-  if (divisor <= 1) return composition
-  const reduced: CompositionType = {}
-  for (const [elem, amt] of Object.entries(composition)) {
-    if (is_valid_element(elem)) reduced[elem] = amt / divisor
-  }
-  return reduced
-}
-
-// Calculate molecular weight (sum of atomic masses * amounts)
-export const get_molecular_weight = (composition: CompositionType): number =>
-  Object.entries(composition).reduce((total, [elem, amount]) => {
-    const mass = is_valid_element(elem) ? (ATOMIC_WEIGHTS.get(elem) ?? 0) : 0
-    return total + mass * amount
-  }, 0)
-
-// Type for element with oxidation state information
-export type ElementWithOxidation = {
-  element: ElementSymbol
-  amount: number
-  oxidation_state?: number
-  orig_idx: number
-}
-
-// Type for composition with oxidation states
-export type OxiComposition = Record<
-  ElementSymbol,
-  { amount: number; oxidation_state?: number }
->
-
-// Parse oxidation state string (e.g. "+2", "2+", "-", "[2-]") to number
-const parse_oxidation_state = (oxidation_str: string): number => {
-  // Handle bare signs: "+", "-" are treated as ±1
-  if (oxidation_str === `+` || oxidation_str === `-`) {
-    return oxidation_str === `+` ? 1 : -1
-  }
-  // Handle formats like "2+", "+2", "2-", "-2"
-  const ox_match = /([+-]?)(\d+)([+-]?)/.exec(oxidation_str)
-  if (!ox_match) return 0
-
-  const [, sign_before, number, sign_after] = ox_match
-  const sign = sign_before || sign_after || `+`
-  return sign === `-` ? -parseInt(number, 10) : parseInt(number, 10)
-}
-
-// Parse chemical formula string with oxidation states into structured data.
-// Supports both ^2+ and [2+] syntax for oxidation states.
-// Examples: "Fe^2+O3", "Fe[2+]O3", "Ca^2+Cl^-2"
-// Tracks original element order from the input string.
-// When strict=true, throws on conflicting oxidation states for the same element.
-export const parse_formula_with_oxidation = (
-  formula: string,
-  strict = false,
-): ElementWithOxidation[] => {
-  const elements: ElementWithOxidation[] = []
-  const cleaned_formula = expand_parentheses(formula.replace(/\s/g, ``))
-
-  // Regex to match: Element, optional oxidation state and/or count in either order
-  // Pattern: ([A-Z][a-z]?)  - element symbol
-  //          Followed by one of:
-  //          - oxidation then optional count: (?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])(count?)
-  //          - count then optional oxidation: count(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])?
-  //          - just oxidation: (?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])
-  //          - just count: count
-  //          - neither
-  const regex =
-    /([A-Z][a-z]?)(?:(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])((?:\d+(?:\.\d+)?|\.\d+)?)|((?:\d+(?:\.\d+)?|\.\d+))(?:\^([+-]?\d+[+-]?|[+-])|\[([+-]?\d+[+-]?|[+-])\])?)?/g
-
-  let match: RegExpExecArray | null
-  let orig_idx = 0
-
-  while ((match = regex.exec(cleaned_formula)) !== null) {
-    const element = match[1]
-    // Oxidation can be in groups 2/3 (oxidation first) or 6/7 (count first)
-    // Count can be in group 4 (after oxidation) or 5 (before oxidation)
-    const oxidation_str = match[2] || match[3] || match[6] || match[7]
-    const count_str = match[4] || match[5]
-    const count = parse_count(count_str)
-
-    if (!is_valid_element(element)) throw new Error(`Invalid element symbol: ${element}`)
-
-    const oxidation_state = oxidation_str ? parse_oxidation_state(oxidation_str) : undefined
-
-    // Find or add element entry
-    const existing = elements.find((el) => el.element === element)
-    if (existing) {
-      existing.amount += count
-
-      // Handle oxidation state conflicts
-      if (oxidation_state === undefined) {
-        // No oxidation state in current match, nothing to do
-      } else if (existing.oxidation_state === undefined) {
-        // Set oxidation state on first occurrence
-        existing.oxidation_state = oxidation_state
-      } else if (strict && existing.oxidation_state !== oxidation_state) {
-        // In strict mode, throw on conflicting oxidation states
-        throw new Error(
-          `Conflicting oxidation states for ${element}: ${format_state(
-            existing.oxidation_state,
-          )} and ${format_state(oxidation_state)}`,
-        )
-      }
-    } else {
-      elements.push({ element, amount: count, oxidation_state, orig_idx: orig_idx++ })
-    }
-  }
-
-  return elements
-}
-
-// Convert OxiComposition to ElementWithOxidation array
-// Does not preserve original order since objects don't have a defined order
-export const oxi_composition_to_elements = (
-  composition: OxiComposition,
-): ElementWithOxidation[] =>
-  Object.entries(composition).flatMap(([element, { amount, oxidation_state }], idx) =>
-    is_valid_element(element) ? [{ element, amount, oxidation_state, orig_idx: idx }] : [],
-  )
-
-// Extract element symbols from a chemical formula.
-// Default (unique=true, sorted=true): "NbZr2Nb" -> ["Nb", "Zr"]
-// unique=false: Fast token extraction preserving order without parentheses expansion
-//   "NbZr2Nb" -> ["Nb", "Zr", "Nb"], "Fe2(SO4)3" -> ["Fe", "S", "O"]
-//   Validates tokens against ELEM_SYMBOLS, filtering out invalid ones.
-// sorted=false: Preserves order of first appearance (only applies when unique=true)
-//   "ZrNb" -> ["Zr", "Nb"]
-export function extract_formula_elements(
-  formula: string,
-  { unique = true, sorted = true }: { unique?: boolean; sorted?: boolean } = {},
-): ElementSymbol[] {
-  if (!unique) {
-    // Fast path: regex token extraction without parentheses expansion
-    const matches = formula.match(/[A-Z][a-z]?/g) ?? []
-    const elements: ElementSymbol[] = []
-    for (const match of matches) {
-      if (is_valid_element(match)) elements.push(match)
-    }
-    return elements
-  }
-  const symbols = Object.keys(parse_formula(formula)).filter(is_valid_element)
-  return sorted ? symbols.sort() : symbols
-}
-
-// Generate all non-empty subsets of a chemical system as hyphenated strings.
-// Input: formula string, composition object, or element symbol array
-// Output: All subsets sorted alphabetically: ["B", "Mo", "Sc", "B-Mo", "B-Sc", "Mo-Sc", "B-Mo-Sc"]
-// Complexity: O(2^n) where n = number of unique elements (fine for typical ~1-5 elements)
-export function generate_chem_sys_subspaces(
-  input: string | CompositionType | ElementSymbol[],
-): string[] {
-  let elements: ElementSymbol[]
-
-  if (typeof input === `string`) elements = extract_formula_elements(input)
-  else if (Array.isArray(input)) {
-    const uniq = [...new Set(input)]
-    for (const elem of uniq) {
-      if (!is_valid_element(elem)) throw new Error(`Invalid element symbol: ${elem}`)
-    }
-    elements = uniq
-  } else {
-    elements = []
-    for (const elem of Object.keys(input)) {
-      if (!is_valid_element(elem)) throw new Error(`Invalid element symbol: ${elem}`)
-      elements.push(elem)
-    }
-  }
-
-  const sorted = [...elements].sort()
-  const subspaces: string[] = []
-  const subset_count = 2 ** sorted.length
-
-  for (let mask = 1; mask < subset_count; mask++) {
-    const subset: string[] = []
-    for (let idx = 0; idx < sorted.length; idx++) {
-      if (mask & (1 << idx)) subset.push(sorted[idx])
-    }
-    subspaces.push(subset.join(`-`))
-  }
-  return subspaces
-}
-
-// Normalize CSV of element symbols to valid symbols in periodic order.
-// Filters invalid symbols, removes duplicates, trims whitespace.
-// Example: "Zr, Nb, InvalidElement, H" -> ["H", "Nb", "Zr"]
-// Note: Matching is case-sensitive. Use all_symbols to filter against a subset.
-export function normalize_element_symbols(csv: string): ElementSymbol[]
-export function normalize_element_symbols<T extends string>(csv: string, all_symbols: T[]): T[]
-export function normalize_element_symbols<T extends string>(
-  csv: string,
-  all_symbols?: T[],
-): Array<ElementSymbol | T> {
-  const input_set = new Set(
-    csv
-      .split(`,`)
-      .map((sym) => sym.trim())
-      .filter(Boolean),
-  )
-  const symbols = all_symbols ?? ELEM_SYMBOLS
-  return symbols.filter((sym) => input_set.has(sym))
-}
-
-// --- Wildcard formula parsing utilities ---
-
-// Type for a parsed formula token (element or wildcard with count)
-export type WildcardFormulaToken = {
-  element: ElementSymbol | null // null indicates wildcard (*)
-  count: number
-}
-
-// Type for parsed chemsys with wildcards
-export type ChemsysWithWildcards = {
-  elements: ElementSymbol[]
-  wildcard_count: number
-}
-
-// Check if input contains wildcard elements (*).
-// Works for both chemsys format (Li-Fe-*-*) and exact formula format (LiFe*2*).
-export const has_wildcards = (input: string): boolean => input.includes(`*`)
-
-// Parse chemsys format with wildcards: "Li-Fe-*-*" -> { elements: ["Li", "Fe"], wildcard_count: 2 }
-// Accepts both hyphen and comma separators.
-// Throws if any non-wildcard token is not a valid element symbol.
-export function parse_chemsys_with_wildcards(input: string): ChemsysWithWildcards {
-  const tokens = input
-    .replace(/-/g, `,`)
-    .split(`,`)
-    .map((tok) => tok.trim())
-    .filter(Boolean)
-
-  const elements: ElementSymbol[] = []
-  let wildcard_count = 0
-
-  for (const token of tokens) {
-    if (token === `*`) {
-      wildcard_count++
-    } else if (is_valid_element(token)) {
-      elements.push(token)
-    } else {
-      throw new Error(`Invalid element symbol or wildcard: ${token}`)
-    }
-  }
-
-  return { elements: elements.sort(), wildcard_count }
-}
-
-// Placeholder for wildcards during parentheses expansion (Zz is not a real element symbol).
-// Use static regex literals to avoid escaping issues if placeholder ever changes.
-export const ELEM_WILDCARD = {
-  placeholder: `Zz`,
-  to_placeholder: /\*/g,
-  from_placeholder: /Zz/g,
-} as const
-
-// Parse exact formula with wildcards: "LiFe*2*" -> [{ element: "Li", count: 1 }, { element: "Fe", count: 1 }, { element: null, count: 2 }, { element: null, count: 1 }]
-// The * character represents any element, optionally followed by a count.
-// Each * in the pattern represents a distinct element position (wildcards cannot share elements).
-// Examples:
-//   "LiFe*2*" -> Li(1), Fe(1), *(2), *(1) - matches formulas with 4 distinct elements
-//   "*2O3" -> *(2), O(3) - matches any binary oxide with 2:3 ratio
-//   "**O4" -> *(1), *(1), O(4) - matches ternary oxides with 1:1:4 ratio
-export function parse_formula_with_wildcards(formula: string): WildcardFormulaToken[] {
-  const tokens: WildcardFormulaToken[] = []
-
-  // Expand parentheses, treating * as a pseudo-element (temporarily replace to protect it)
-  let cleaned = formula.replace(/\s/g, ``)
-
-  // Protect wildcards from parentheses expansion by replacing * with placeholder
-  cleaned = cleaned.replace(ELEM_WILDCARD.to_placeholder, ELEM_WILDCARD.placeholder)
-  cleaned = expand_parentheses(cleaned)
-  // Restore wildcards
-  cleaned = cleaned.replace(ELEM_WILDCARD.from_placeholder, `*`)
-
-  // Regex to match either:
-  // 1. Standard element symbol with optional decimal count
-  // 2. Wildcard with optional decimal count
-  const regex = /([A-Z][a-z]?)((?:\d+(?:\.\d+)?|\.\d+)?)|(\*)((?:\d+(?:\.\d+)?|\.\d+)?)/g
-
-  let match: RegExpExecArray | null
-  while ((match = regex.exec(cleaned)) !== null) {
-    if (match[3] === `*`) {
-      // Wildcard match
-      const count = parse_count(match[4])
-      tokens.push({ element: null, count })
-    } else if (match[1]) {
-      // Element symbol match
-      const element = match[1]
-      const count = parse_count(match[2])
-
-      if (!is_valid_element(element)) {
-        throw new Error(`Invalid element symbol: ${element}`)
-      }
-      tokens.push({ element, count })
-    }
-  }
-
-  return tokens
-}
-
-// Check if a formula matches a chemsys pattern with wildcards.
-// The formula must contain exactly the specified elements plus wildcard_count additional distinct elements.
-// Example: matches_chemsys_wildcard("LiFeCoO", ["Li", "Fe"], 2) -> true (Co and O fill the wildcards)
-export function matches_chemsys_wildcard(
-  formula: string,
-  explicit_elements: string[],
-  wildcard_count: number,
-): boolean {
-  try {
-    const formula_elements = extract_formula_elements(formula, { unique: true })
-    const required_count = explicit_elements.length + wildcard_count
-
-    // Must have exactly the right number of elements
-    if (formula_elements.length !== required_count) return false
-
-    // Must contain all explicit elements
-    const formula_set = new Set(formula_elements)
-    for (const elem of explicit_elements) {
-      if (!is_valid_element(elem) || !formula_set.has(elem)) return false
-    }
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Check if a formula matches an exact formula pattern with wildcards.
-// Each wildcard (*) must be satisfied by a distinct element not used by explicit elements or other wildcards.
-// Example: matches_formula_wildcard("LiFeCoNiO4", [{element: "Li", count: 1}, {element: null, count: 1}, ...])
-export function matches_formula_wildcard(
-  formula: string,
-  pattern: WildcardFormulaToken[],
-): boolean {
-  try {
-    const composition = parse_formula(formula)
-
-    // Separate explicit elements and wildcards from pattern
-    const explicit_requirements: Array<{ element: ElementSymbol; count: number }> = []
-    const wildcard_counts: number[] = []
-
-    for (const token of pattern) {
-      if (token.element === null) {
-        wildcard_counts.push(token.count)
-      } else {
-        // Merge counts for same element (e.g. "LiLi" -> Li with count 2)
-        const existing = explicit_requirements.find((req) => req.element === token.element)
-        if (existing) {
-          existing.count += token.count
-        } else {
-          explicit_requirements.push({ element: token.element, count: token.count })
-        }
-      }
-    }
-
-    // Check explicit element requirements
-    const used_elements = new Set<string>()
-    for (const req of explicit_requirements) {
-      if (composition[req.element] !== req.count) return false
-      used_elements.add(req.element)
-    }
-
-    // Get remaining elements (candidates for wildcards)
-    const remaining_elements = Object.entries(composition)
-      .filter(([elem]) => !used_elements.has(elem))
-      .map(([elem, count]) => ({ elem, count }))
-
-    // Must have exactly as many remaining elements as wildcards
-    if (remaining_elements.length !== wildcard_counts.length) return false
-
-    // Try to match remaining elements to wildcards (each wildcard needs a distinct element)
-    // Sort both by count to enable greedy matching
-    const sorted_remaining = [...remaining_elements].sort((a, b) => a.count - b.count)
-    const sorted_wildcards = [...wildcard_counts].sort((a, b) => a - b)
-
-    // Check if counts match (simple comparison works because we need exact matches)
-    for (let idx = 0; idx < sorted_wildcards.length; idx++) {
-      if (sorted_remaining[idx].count !== sorted_wildcards[idx]) return false
-    }
-
-    return true
-  } catch {
-    return false
-  }
-}