pub fn parse(text: &str, file_path: &str) -> Result<RawTurboJson, Error> {
        let result = deserialize_from_json_str::<RawTurboJson>(
            text,
            JsonParserOptions::default()
                .with_allow_comments()
                .with_allow_trailing_commas(),
            file_path,
        );

        if !result.diagnostics().is_empty() {
            let diagnostics = result
                .into_diagnostics()
                .into_iter()
                .map(|d| {
                    d.with_file_source_code(text)
                        .with_file_path(file_path)
                        .as_ref()
                        .into()
                })
                .collect();

            return Err(Error {
                diagnostics,
                backtrace: backtrace::Backtrace::capture(),
            });
        }

        // It's highly unlikely that biome would fail to produce a deserialized value
        // *and* not return any errors, but it's still possible. In that case, we
        // just print that there is an error and return.
        let mut turbo_json = result.into_deserialized().ok_or_else(|| Error {
            diagnostics: vec![],
            backtrace: backtrace::Backtrace::capture(),
        })?;

        if turbo_json.experimental_spaces.is_some() {
            warn!("`experimentalSpaces` key in turbo.json is deprecated and does not do anything")
        }

        turbo_json.add_text(Arc::from(text));
        turbo_json.add_path(Arc::from(file_path));

        Ok(turbo_json)
    }
Parses a turbo.json file into the raw representation with span info
attached.

# Arguments

* `text`: The text contents of the turbo.json file
* `file_path`: The path to the turbo.json file. Just used for error
display, so doesn't need to actually be a correct path.

returns: Result<RawTurboJson, Error>
crates/turborepo-lib/src/turbo_json/parser.rs