// Ignore any messages printed to the `Output` channel (used by `tracing`)

    // Ignore any messages printed to the `Output` channel (used by `tracing`).
    // Since the output view is a text document, any logging calls will trigger this function,
    // so make sure to return before it sends itself into an infinite loop.

    }
    let uri = UriAbsoluteString::try_from(document_uri.to_string()?)
        .map_err(|error| napi::Error::from_reason(format!("Failed to parse URI: {error}")))?;
    let change_events = event.get_content_changes()?;
    let mut changes = Vec::with_capacity(change_events.len());
    for change_event in &change_events {
        changes.push(event_loop::EditorContentsChange {
            character_offset: change_event.get_range_offset()?,
            characters_replaced: change_event.get_range_length()?,
            replacement_text: change_event.get_text()?,
        })

    event_loop::send(Event::ChangeEditorContents { uri, changes });

        let change_events = event.get_content_changes()?;

use iri_string::types::{UriAbsoluteStr, UriAbsoluteString};

use iri_string::types::UriAbsoluteStr;

// Re-export Event so it can be used by callers
pub use event::Event;

// Re-export Event types so it can be used by callers
pub use event::{EditorContentsChange, Event};

                }
                Event::ChangeEditorContents { uri, changes } => {
                    event::change_editor_contents::handle(uri, changes, &mut extension_state).await

pub mod change_editor_contents;

#[derive(Debug)]
pub struct EditorContentsChange {
    pub character_offset: u32,
    pub characters_replaced: u32,
    pub replacement_text: String,
}

    },
    ChangeEditorContents {
        uri: UriAbsoluteString,
        changes: Vec<EditorContentsChange>,

use iri_string::types::UriAbsoluteString;
use crate::event_loop::{EditorContentsChange, ExtensionState};
#[tracing::instrument(skip(extension_state))]
pub async fn handle(
    uri: UriAbsoluteString,
    changes: Vec<EditorContentsChange>,
    extension_state: &mut ExtensionState,
) {
    let Some((_repository_path, relative_path, repository)) =
        extension_state.get_repository_mut(&uri)
    else {
        tracing::info!(message = "Ignoring text content changes");
        return;
    };
    for change in changes {
        let EditorContentsChange {
            character_offset,
            characters_replaced,
            replacement_text,
        } = change;
        if let Err(error) = repository.repository.update_open_file(
            relative_path,
            character_offset as usize,
            characters_replaced as usize,
            &replacement_text,
        ) {
            tracing::error!(message = "Failed to update open file", ?error);
            return;
        }
        tracing::info!(message = "Updated open file");
    }
}