"scm": scm {

    scm ("scm": napi::bindgen_prelude::Object) {

threadsafe_function! {
    uri ("Uri": napi::bindgen_prelude::Function<napi::Unknown, napi::Unknown>) {
        "file":
            file(
                String
            ) -> crate::vscode_sys::reference::UriRef;
    }
}

        $js_namespace_name:literal: $module_name:ident {

        $module_name:ident ($js_parent_name:literal: $js_parent_type:ty){

                    pub fn get(env: &napi::Env) -> Result<Prototype, napi::Error> {
                        let vscode_object = crate::vscode_sys::VscodeContext::vscode(env)?;
                        let namespace: napi::bindgen_prelude::Object = vscode_object.get_named_property($js_namespace_name)?;

                    pub fn get(vscode_object: &napi::bindgen_prelude::Object) -> Result<Prototype, napi::Error> {
                        let parent: $js_parent_type = vscode_object.get_named_property($js_parent_name)?;

                        namespace.get_named_property($function_js_name)

                        parent.get_named_property($function_js_name)

    event_loop::start(env)?;

    event_loop::start(&vscode_object)?;

use napi::bindgen_prelude::FnArgs;

use napi::bindgen_prelude::{FnArgs, Object};

    uri_file: vscode_sys::threadsafe_function::uri::file::Prototype,

    pub fn get(env: &napi::Env) -> Result<Self, napi::Error> {

    pub fn get(vscode_object: &Object) -> Result<Self, napi::Error> {

                vscode_sys::threadsafe_function::scm::create_source_control::get(env)?,

                vscode_sys::threadsafe_function::scm::create_source_control::get(vscode_object)?,
            uri_file: vscode_sys::threadsafe_function::uri::file::get(vscode_object)?,

        uri: &str,

        uri: crate::vscode_sys::reference::UriRef,

        let arguments = FnArgs::from((id, name, None));

        let arguments = FnArgs::from((id, name, Some(uri)));

    }
    pub async fn uri_file(
        &self,
        path: String,
    ) -> Result<vscode_sys::reference::UriRef, napi::Error> {
        let arguments = FnArgs::from((path,));
        self.uri_file.call_async(arguments).await

use camino::Utf8PathBuf;
use iri_string::types::UriAbsoluteStr;

                Event::OpenWorkspaceFolder { uri } => {
                    // TODO: handle multiple repositories per workspace
                    // TODO: properly handle URIs

                Event::OpenWorkspaceFolder { uri: raw_uri } => {
                    let uri = match UriAbsoluteStr::new(raw_uri) {
                        Ok(valid_uri) => valid_uri,
                        Err(error) => {
                            tracing::error!(message = "Invalid URI", ?raw_uri, ?error);
                            continue;
                        }
                    };
                    // TODO: handle different schemes using `vscode.workspace.fs`
                    if uri.scheme_str() != "file" {
                        tracing::info!(message = "Skipping unhandled URI scheme", ?uri);
                        continue;
                    }
                    let workspace_path = Utf8PathBuf::from(uri.path_str());
                    // TODO: multiple repositories per workspace
                    let repository_path = workspace_path.clone();
                    let repository_uri_ref = match threadsafe_functions
                        .uri_file(repository_path.to_string())
                        .await
                    {
                        Ok(repository_uri_ref) => repository_uri_ref,
                        Err(error) => {
                            tracing::error!(
                                message = "Failed to parse URI",
                                ?repository_path,
                                ?error
                            );
                            continue;
                        }
                    };

                        .create_source_control(String::from("pijul"), String::from("Pijul"), uri)

                        .create_source_control(
                            String::from("pijul"),
                            String::from("Pijul"),
                            repository_uri_ref,
                        )

                    tracing::info!(message = "Opened workspace folder", ?workspace_path);

pub fn start(env: &napi::Env) -> Result<(), napi::Error> {
    let threadsafe_functions = threadsafe_function::ThreadsafeFunctions::get(env)?;

pub fn start(vscode_object: &napi::bindgen_prelude::Object) -> Result<(), napi::Error> {
    let threadsafe_functions = threadsafe_function::ThreadsafeFunctions::get(vscode_object)?;

iri-string.workspace = true

iri-string = "0.7"

name = "iri-string"
version = "0.7.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f867b9d1d896b67beb18518eda36fdb77a32ea590de864f1325b294a6d14397"
dependencies = [
 "memchr",
 "serde",
]
[[package]]

 "iri-string",