Method new

src/format/format.rs:136–289

(
        country_format: &CountryFormat,
        prefix: Option<String>,
        suffix_filter: Option<String>,
        infix_filter: Option<String>,
        digit_override: Option<usize>,
    )

// Now modify the new() method to accept an infix parameter
impl PhoneNumberGenerator {
    pub fn new(
        country_format: &CountryFormat,
        prefix: Option<String>,
        suffix_filter: Option<String>,
        infix_filter: Option<String>,
        digit_override: Option<usize>,
    ) -> Result<Self, Error> {
        let country_code = country_format.code.clone();
        
        // Get the format-defined digits (how many digits in a complete number for this country)
        let format_digits = if let Some(d) = digit_override {
            d
        } else {
            match get_digits_for_country(country_format) {
                Ok(digit_lengths) => {
                    if digit_lengths.is_empty() {
                        return Err(anyhow!("No digit length specified for country code: {}. Check format.json", country_code));
                    }
                    // Use the first/minimum digit length
                    *digit_lengths.iter().min().unwrap()
                },
                Err(e) => return Err(e)
            }
        };
        
        // Calculate the standard area code length for this country
        let standard_area_code_len = if !country_format.area_codes.is_empty() {
            // Most countries have consistent area code lengths, so we can use the first one
            // as a reference
            country_format.area_codes[0].len()
        } else {
            0 // No area codes
        };
        
        // Filter available area codes and calculate remaining parts based on user-provided prefix
        let (selected_area_codes, remaining_area_code_parts, digits_to_generate) = 
            if let Some(p) = &prefix {
                // Using a user-defined prefix:
                // 1. If prefix is shorter than or equal to expected area code length, 
                //    use it to filter area codes
                // 2. If prefix is longer than area codes, split it to extract area code 
                //    and starting digits
                
                // Check if any area codes are defined for this country
                if country_format.area_codes.is_empty() {
                    // No area codes specified, use empty string as the only "area code"
                    // and generate numbers with the full prefix
                    (
                        vec!["".to_string()],
                        vec!["".to_string()], 
                        format_digits.saturating_sub(p.len())
                    )
                } else {
                    if p.len() <= standard_area_code_len {
                        // Prefix is shorter than or equal to typical area code length
                        // Filter area codes that start with this prefix
                        let mut matching_codes = Vec::new();
                        let mut remaining_parts = Vec::new();