Cannot ignore whitespace without changing the width of the span about chumsky HOT 3 CLOSED

pub fn lexer<'src>() -> impl Parser<
    'src,
    &'src str,
    Vec<(Token<'src>, SimpleSpan<usize>)>,
    extra::Err<Rich<'src, char, SimpleSpan<usize>>>,
> {
    let boolean = choice((
        just("true").to(Token::Boolean(true)),
        just("false").to(Token::Boolean(false)),
    ));

    let float_numeric = just('-')
        .or_not()
        .then(text::int(10))
        .then(just('.').then(text::digits(10)))
        .then(just('e').then(text::digits(10)).or_not())
        .to_slice()
        .map(|text: &str| Token::Float(text.parse().unwrap()));

    let float_other = choice((just("Infinity"), just("-Infinity"), just("NaN")))
        .map(|text| Token::Float(text.parse().unwrap()));

    let float = choice((float_numeric, float_other));

    let integer = just('-')
        .or_not()
        .then(text::int(10))
        .to_slice()
        .map(|text: &str| {
            let integer = text.parse::<i64>().unwrap();

            Token::Integer(integer)
        });

    let delimited_string = |delimiter| {
        just(delimiter)
            .then(none_of(delimiter).repeated())
            .then(just(delimiter))
            .to_slice()
            .map(|text: &str| Token::String(&text[1..text.len() - 1]))
    };

    let string = choice((
        delimited_string('\''),
        delimited_string('"'),
        delimited_string('`'),
    ));

    let identifier = text::ident().map(|text: &str| Token::Identifier(text));

    let operator = choice((
        // logic
        just("&&").to(Operator::And),
        just("==").to(Operator::Equal),
        just("!=").to(Operator::NotEqual),
        just(">=").to(Operator::GreaterOrEqual),
        just("<=").to(Operator::LessOrEqual),
        just(">").to(Operator::Greater),
        just("<").to(Operator::Less),
        just("!").to(Operator::Not),
        just("!=").to(Operator::NotEqual),
        just("||").to(Operator::Or),
        // assignment
        just("=").to(Operator::Assign),
        just("+=").to(Operator::AddAssign),
        just("-=").to(Operator::SubAssign),
        // math
        just("+").to(Operator::Add),
        just("-").to(Operator::Subtract),
        just("*").to(Operator::Multiply),
        just("/").to(Operator::Divide),
        just("%").to(Operator::Modulo),
    ))
    .map(Token::Operator);

    let control = choice((
        just("->").to(Control::Arrow),
        just("{").to(Control::CurlyOpen),
        just("}").to(Control::CurlyClose),
        just("[").to(Control::SquareOpen),
        just("]").to(Control::SquareClose),
        just("(").to(Control::ParenOpen),
        just(")").to(Control::ParenClose),
        just(",").to(Control::Comma),
        just(";").to(Control::Semicolon),
        just("::").to(Control::DoubleColon),
        just(":").to(Control::Colon),
        just("..").to(Control::DoubleDot),
        just(".").to(Control::Dot),
    ))
    .map(Token::Control);

    let keyword = choice((
        just("any").to(Keyword::Any),
        just("bool").to(Keyword::Bool),
        just("break").to(Keyword::Break),
        just("else").to(Keyword::Else),
        just("float").to(Keyword::Float),
        just("int").to(Keyword::Int),
        just("if").to(Keyword::If),
        just("list").to(Keyword::List),
        just("map").to(Keyword::Map),
        just("none").to(Keyword::None),
        just("range").to(Keyword::Range),
        just("struct").to(Keyword::Struct),
        just("str").to(Keyword::Str),
        just("loop").to(Keyword::Loop),
        just("while").to(Keyword::While),
    ))
    .map(Token::Keyword);

    choice((
        boolean, float, integer, string, keyword, identifier, control, operator,
    ))
    .map_with(|token, state| (token, state.span()))
    .padded()
    .repeated()
    .collect()
}