use camino::Utf8PathBuf;
use clap::Parser;
mod build;
#[derive(Debug, clap::Parser)]
pub enum SubCommand {
    Build(build::Args),
}
#[derive(Clone, Copy, Debug, clap::ValueEnum)]
pub enum ExtensionTarget {
    #[value(name = "vscode")]
    VisualStudioCode,
}
impl ExtensionTarget {
    pub fn name(&self) -> &str {
        match self {
            ExtensionTarget::VisualStudioCode => "vscode",
        }
    }
    pub fn base_path(&self, metadata: &cargo_metadata::Metadata) -> Utf8PathBuf {
        // TODO: get the workspace root
        let workspace_root = &metadata.workspace_root;
        assert!(workspace_root.exists());
        assert!(workspace_root.is_dir());
        let path = workspace_root.join("extensions").join(self.name());
        assert!(path.exists());
        assert!(path.is_dir());
        path
    }
}
fn main() -> Result<(), anyhow::Error> {
    let sub_command = SubCommand::parse();
    let metadata = cargo_metadata::MetadataCommand::new().exec()?;
    match sub_command {
        SubCommand::Build(args) => args.run(&metadata),
    }
}

use std::process::Command;
use crate::ExtensionTarget;
#[derive(Debug, clap::Parser)]
pub struct Args {
    #[arg(value_enum)]
    extension_target: ExtensionTarget,
}
impl Args {
    pub fn run(&self, metadata: &cargo_metadata::Metadata) -> Result<(), anyhow::Error> {
        let base_path = self.extension_target.base_path(metadata);
        // TODO: walk the tree before/after build to make sure no artifacts were missed
        match self.extension_target {
            ExtensionTarget::VisualStudioCode => {
                // Steps:
                // 1. Install all dependencies
                // 2. Build native Rust module
                // 3. Build TypeScript code
                let out_dir = base_path.join("out");
                let native_module = out_dir.join("native-module");
                std::fs::create_dir_all(&out_dir)?;
                std::fs::create_dir_all(&native_module)?;
                // TODO: pnpm install?
                // TODO: release builds
                // TODO: multiple targets
                let mut rust_build = Command::new("pnpm");
                rust_build.current_dir(&base_path);
                rust_build.args([
                    "exec",
                    "napi",
                    "build",
                    "--platform",
                    "--output-dir",
                    native_module.as_str(),
                    "--target",
                    "x86_64-unknown-linux-gnu",
                ]);
                let rust_exit_status = rust_build.status()?;
                assert!(rust_exit_status.success());
                let mut typescript_build = Command::new("pnpm");
                typescript_build.current_dir(base_path);
                typescript_build.args(["exec", "tsc", "--outDir", out_dir.as_str()]);
                let typescript_exit_status = typescript_build.status()?;
                assert!(typescript_exit_status.success());
            }
        }
        Ok(())
    }
}

[package]
name = "xtask"
publish = false
description = "Build scripts using the cargo-xtask pattern"
# Keys inherited from workspace
authors.workspace = true
categories.workspace = true
edition.workspace = true
keywords.workspace = true
license.workspace = true
repository.workspace = true
version.workspace = true
[dependencies]
anyhow.workspace = true
camino.workspace = true
cargo_metadata.workspace = true
clap.workspace = true

// TODO: rewrite to be generic over filesystem implementations
use std::collections::HashSet;
use camino::{Utf8Path, Utf8PathBuf};
use canonical_path::CanonicalPathBuf;
use libpijul::pristine::sanakirja::{MutTxn, SanakirjaError};
use libpijul::{ArcTxn, TxnTExt};
#[derive(Debug, thiserror::Error)]
pub enum UntrackedItemError {
    #[error("unable to get untracked path from filesystem: {0:#?}")]
    IO(std::io::Error),
    #[error("unable to check if path is tracked: {0:#?}")]
    IsTracked(SanakirjaError),
    #[error("unable to convert `{invalid_path:#?}` to UTF-8: {conversion_error:#?}")]
    Utf8Path {
        invalid_path: std::path::PathBuf,
        conversion_error: camino::FromPathBufError,
    },
}
#[derive(Debug, thiserror::Error)]
#[error(transparent)]
pub enum UntrackedError {
    #[error("unable to get available parallelism: {0:#?}")]
    AvailableParallelism(std::io::Error),
    #[error("unable to canonicalize root path `{root_path}`: {io_error:#?}")]
    CanonicalRoot {
        root_path: Utf8PathBuf,
        io_error: std::io::Error,
    },
    #[error("unable to iterate untracked files: {0:#?}")]
    Iteration(std::io::Error),
    #[error(transparent)]
    IterationItem(#[from] UntrackedItemError),
}
pub fn file_system(
    root: &Utf8Path,
    file_system: &libpijul::working_copy::FileSystem,
    transaction: ArcTxn<MutTxn<()>>,
) -> Result<HashSet<Utf8PathBuf>, UntrackedError> {
    let untracked_items_transaction = transaction.clone();
    let canonical_path =
        CanonicalPathBuf::canonicalize(root).map_err(|io_error| UntrackedError::CanonicalRoot {
            root_path: root.to_path_buf(),
            io_error,
        })?;
    let untracked_files: HashSet<Utf8PathBuf> = file_system
        .iterate_prefix_rec(
            canonical_path.clone(),
            canonical_path,
            false,
            std::thread::available_parallelism()
                .map_err(UntrackedError::AvailableParallelism)?
                .get(),
            // Follow all paths
            |_path, _is_directory| true,
        )
        .map_err(UntrackedError::Iteration)?
        // Handle any errors in iteration
        .map(|filesystem_result| match filesystem_result {
            Ok((path, _is_directory)) => {
                Utf8PathBuf::try_from(path.clone()).map_err(|conversion_error| {
                    UntrackedItemError::Utf8Path {
                        invalid_path: path,
                        conversion_error,
                    }
                })
            }
            Err(io_error) => Err(UntrackedItemError::IO(io_error)),
        })
        // Filter out tracked paths
        .filter_map(|path_result| match path_result {
            Ok(path) => match untracked_items_transaction.read().is_tracked(path.as_str()) {
                Ok(true) => None,
                Ok(false) => Some(Ok(path)),
                Err(error) => Some(Err(UntrackedItemError::IsTracked(error))),
            },
            Err(error) => Some(Err(error)),
        })
        .collect::<Result<_, UntrackedItemError>>()?;
    Ok(untracked_files)
}

use std::collections::HashMap;
use camino::Utf8PathBuf;
use libpijul::change::BaseHunk;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::sanakirja::{MutTxn, SanakirjaError};
use libpijul::working_copy::WorkingCopy;
use libpijul::{ArcTxn, ChannelRef, RecordBuilder};
use crate::TrackedState;
#[derive(Debug, thiserror::Error)]
pub enum ModifiedPathsError<C: std::error::Error + 'static, W: std::error::Error> {
    Globalize(#[from] SanakirjaError),
    Record(#[from] libpijul::record::RecordError<C, W, MutTxn<()>>),
}
pub fn modified_paths<C, W>(
    transaction: &ArcTxn<MutTxn<()>>,
    channel: &ChannelRef<MutTxn<()>>,
    working_copy: &W,
    change_store: &C,
) -> Result<HashMap<Utf8PathBuf, TrackedState>, ModifiedPathsError<C::Error, W::Error>>
where
    C: ChangeStore + Clone + Send + 'static,
    W: WorkingCopy + Clone + Send + Sync + 'static,
{
    let mut unrecorded_changes = RecordBuilder::new();
    unrecorded_changes.record(
        transaction.clone(),
        libpijul::Algorithm::default(),
        false, // TODO: check and document
        &libpijul::DEFAULT_SEPARATOR,
        channel.clone(),
        working_copy,
        change_store,
        "",
        1, // TODO: figure out concurrency model
    )?;
    let unrecorded_state = unrecorded_changes.finish();
    let mut modified_paths = HashMap::new();
    for hunk in unrecorded_state.actions {
        match hunk {
            BaseHunk::FileMove { path, .. } => {
                modified_paths
                    .entry(Utf8PathBuf::from(path))
                    .and_modify(|path_state| match path_state {
                        TrackedState::Modified => *path_state = TrackedState::ModifiedAndMoved,
                        _ => unreachable!("{path_state:#?}"),
                    })
                    .or_insert(TrackedState::Moved);
            }
            BaseHunk::FileDel { path, .. } => {
                modified_paths
                    .try_insert(Utf8PathBuf::from(path), TrackedState::Removed)
                    .unwrap();
            }
            BaseHunk::FileAdd { path, .. } => {
                modified_paths
                    .try_insert(Utf8PathBuf::from(path), TrackedState::Added)
                    .unwrap();
            }
            BaseHunk::Edit { local, .. } | BaseHunk::Replacement { local, .. } => {
                modified_paths
                    .entry(Utf8PathBuf::from(local.path))
                    .and_modify(|path_state| match path_state {
                        TrackedState::Modified => (),
                        TrackedState::Moved => *path_state = TrackedState::ModifiedAndMoved,
                        _ => unreachable!("{path_state:#?}"),
                    })
                    .or_insert(TrackedState::Modified);
            }
            // TODO: FileUndel
            // TODO: conflicts
            _ => continue,
        }
    }
    Ok(modified_paths)
}

#![feature(map_try_insert)]
// TODO: cache wherever possible
// TODO: audit pub fields
// TODO: changestore/pristine FileSystem integration should integrate with WorkingCopy(Read) traits
// TODO: test against memfs to make sure alternative filesystems are supported https://github.com/microsoft/vscode-extension-samples/blob/main/fsprovider-sample/README.md
// TODO: zero-copy data if possible?
// TODO: try do one transaction per function call (no inline .read() etc) - unless maybe if only one read/write call?
// TODO: atomic updates to everything? e.g. write working copy and pristine in one go so everything stays in sync
// TODO: inject like 10secs of latency everywhere to make sure cancellation works properly (same for any await point - could introduce TOCTOU bugs)
// TODO: update tracked state when externally modified on disk (e.g. pijul command directly) - and figure out how to test this?
// TODO: make sure paths are based in the root of the repo
use std::collections::{HashMap, HashSet};
use camino::{Utf8Path, Utf8PathBuf};
use libpijul::change::ChangeHeader;
use libpijul::changestore;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::TxnErr;
use libpijul::pristine::sanakirja::{MutTxn, Pristine, SanakirjaError};
use libpijul::working_copy::WorkingCopy;
use libpijul::working_copy::{self, WorkingCopyRead};
use libpijul::{ArcTxn, ChangeId, ChannelRef, TxnT};
use crate::author::{AuthorSource, Authors};
use crate::channel_state::{ChannelState, ChannelStateError};
use crate::file_system::changes::unrecorded::UnrecordedChangesError;
use crate::file_system::open_file::{OpenFile, OpenFileError};
use crate::file_system::working_copy::EditorWorkingCopy;
use crate::modified_paths::ModifiedPathsError;
pub mod author;
pub mod channel_state;
pub mod file_system;
pub mod modified_paths;
pub mod untracked;
#[derive(Debug, thiserror::Error)]
pub enum RepositoryError<C: std::error::Error + 'static, W: std::error::Error + 'static> {
    #[error("unable to open pristine: {0:#?}")]
    Pristine(#[from] SanakirjaError),
    #[error("unable to begin transaction: {0:#?}")]
    BeginTransaction(#[from] BeginTransactionError),
    #[error("unable to get untracked paths: {0:#?}")]
    Untracked(#[from] untracked::UntrackedError),
    #[error("failed to log changes: {0:#?}")]
    Changes(#[from] ChannelStateError<C>),
    #[error("unable to get modified paths: {0:#?}")]
    Modified(#[from] ModifiedPathsError<C, W>),
}
#[derive(Debug, thiserror::Error)]
pub enum BeginTransactionError {
    #[error("unable to begin transaction: {0:#?}")]
    Transaction(#[from] SanakirjaError),
    #[error("unable to open channel: {0:#?}")]
    Channel(#[from] TxnErr<SanakirjaError>),
}
#[derive(Debug, thiserror::Error)]
pub enum CreditError {
    #[error("error while checking if `{path}` is tracked: {error:#?}")]
    GetIsTracked {
        path: Utf8PathBuf,
        error: SanakirjaError,
    },
    #[error("missing open file for {0}")]
    MissingOpenFile(Utf8PathBuf),
}
#[derive(Debug, thiserror::Error)]
pub enum CreateOpenFileError<C: std::error::Error + 'static, W: std::error::Error + 'static> {
    #[error("unable to get metadata for file: {0:?}")]
    FileMetadata(W),
    #[error(transparent)]
    OpenFile(#[from] OpenFileError<C>),
    #[error("File already open at {0}")]
    AlreadyOpen(Utf8PathBuf),
}
#[derive(Debug, thiserror::Error)]
pub enum UpdateOpenFileError<C: std::error::Error + 'static> {
    #[error(transparent)]
    UnrecordedChanges(#[from] UnrecordedChangesError<C>),
    #[error("No file open at {0}")]
    NoMatchingFile(Utf8PathBuf),
    #[error("Unable to begin transaction: {0:#?}")]
    BeginTransaction(#[from] BeginTransactionError),
}
#[derive(Clone, Copy, Debug)]
pub enum TrackedState {
    Added,
    Removed,
    Modified,
    Moved,
    ModifiedAndMoved,
}
#[derive(Debug)]
pub enum PathState {
    Untracked,
    Tracked(TrackedState),
}
pub type FileSystemRepository =
    Repository<changestore::filesystem::FileSystem, working_copy::FileSystem>;
pub struct Repository<C, W>
where
    C: ChangeStore + Clone + Send + 'static,
    W: WorkingCopy + Clone + Send + Sync + 'static,
{
    pub authors: Authors,
    pub channel_state: ChannelState,
    pub working_copy: EditorWorkingCopy<W>,
    // TODO: use a trie
    pub untracked: HashSet<Utf8PathBuf>,
    pub modified_paths: HashMap<Utf8PathBuf, TrackedState>,
    pub change_store: C,
    pub pristine: Pristine,
}
impl FileSystemRepository {
    pub fn new(
        root: &Utf8Path,
        // TODO: take open files here
    ) -> Result<Self, RepositoryError<changestore::filesystem::Error, std::io::Error>> {
        let dot_directory = root.join(libpijul::DOT_DIR);
        let change_store = changestore::filesystem::FileSystem::from_root(root.as_str(), 256);
        let pristine = Pristine::new(dot_directory.join("pristine").join("db").as_str())?;
        let file_system = working_copy::FileSystem::from_root(root.as_str());
        let (transaction, channel) = begin_transaction(&pristine)?;
        let working_copy = EditorWorkingCopy::new(file_system);
        let channel_state = ChannelState::new(&transaction, &channel, &change_store)?;
        let authors = Authors::new(&channel_state, &dot_directory);
        let untracked =
            untracked::file_system(root, &working_copy.working_copy, transaction.clone())?;
        let modified_paths = modified_paths::modified_paths(
            &transaction,
            &channel,
            &working_copy.working_copy,
            &change_store,
        )?;
        Ok(Self {
            authors,
            channel_state,
            working_copy,
            untracked,
            modified_paths,
            change_store,
            pristine,
        })
    }
}
impl<C, W> Repository<C, W>
where
    C: ChangeStore + Clone + Send + 'static,
    W: WorkingCopy + Clone + Send + Sync + 'static,
{
    pub fn get_change_header(&self, change_id: &ChangeId) -> Option<&ChangeHeader> {
        self.channel_state.get_change_header(change_id)
    }
    pub fn get_path_state(&self, path: &Utf8Path) -> Option<PathState> {
        if self.untracked.contains(path) {
            Some(PathState::Untracked)
        } else {
            self.modified_paths
                .get(path)
                .map(|path_state| PathState::Tracked(*path_state))
        }
    }
    pub fn is_untracked(&self, path: &Utf8Path) -> bool {
        self.untracked.contains(path)
    }
    pub fn iter_modified(&self) -> impl Iterator<Item = &Utf8PathBuf> {
        self.modified_paths.keys()
    }
    pub fn iter_untracked(&self) -> impl Iterator<Item = &Utf8PathBuf> {
        self.untracked.iter()
    }
    pub fn authors_for_change(&self, change_header: &ChangeHeader) -> Vec<&AuthorSource> {
        self.authors.authors_for_change(change_header)
    }
    pub fn create_open_file(
        &mut self,
        path: Utf8PathBuf,
        file_contents: String,
    ) -> Result<(), CreateOpenFileError<C::Error, W::Error>> {
        let metadata = self
            .working_copy
            .file_metadata(path.as_str())
            .map_err(CreateOpenFileError::FileMetadata)?;
        let (transaction, channel) = begin_transaction(&self.pristine).unwrap();
        let open_file = OpenFile::open(
            path.clone(),
            file_contents,
            metadata,
            &transaction,
            &channel,
            &self.change_store,
            &self.working_copy,
        )?;
        self.working_copy
            .open_files
            .try_insert(path.clone(), open_file)
            .map_err(|_error| CreateOpenFileError::AlreadyOpen(path))?;
        Ok(())
    }
    pub fn update_open_file(
        &mut self,
        path: &Utf8Path,
        character_offset: usize,
        characters_replaced: usize,
        replacement_text: &str,
    ) -> Result<(), UpdateOpenFileError<C::Error>> {
        let open_file = self
            .working_copy
            .open_files
            .get_mut(path)
            .ok_or_else(|| UpdateOpenFileError::NoMatchingFile(path.to_path_buf()))?;
        let (transaction, channel) = begin_transaction(&self.pristine)?;
        open_file.update(
            character_offset,
            characters_replaced,
            replacement_text,
            &transaction,
            &channel,
            &self.change_store,
        )?;
        Ok(())
    }
    pub fn get_open_file(&self, path: &Utf8Path) -> Option<&OpenFile> {
        self.working_copy.open_files.get(path)
    }
}
fn begin_transaction(
    pristine: &Pristine,
) -> Result<(ArcTxn<MutTxn<()>>, ChannelRef<MutTxn<()>>), BeginTransactionError> {
    let transaction = pristine.arc_txn_begin()?;
    let channel = transaction
        .read()
        .load_channel(
            transaction
                .read()
                .current_channel()
                .unwrap_or(libpijul::DEFAULT_CHANNEL),
        )?
        .unwrap();
    Ok((transaction, channel))
}

use std::collections::HashMap;
use camino::{Utf8Path, Utf8PathBuf};
use libpijul::working_copy::WorkingCopy;
use libpijul::working_copy::WorkingCopyRead;
use crate::file_system::open_file::OpenFile;
#[derive(Clone)]
pub struct EditorWorkingCopy<W: WorkingCopy + Clone + Send + Sync + 'static> {
    pub working_copy: W,
    pub open_files: HashMap<Utf8PathBuf, OpenFile>,
}
impl<W: WorkingCopy + Clone + Send + Sync + 'static> EditorWorkingCopy<W> {
    pub fn new(working_copy: W) -> Self {
        Self {
            working_copy,
            open_files: HashMap::new(),
        }
    }
}
impl<W: WorkingCopy + Clone + Send + Sync + 'static> WorkingCopyRead for EditorWorkingCopy<W> {
    type Error = W::Error;
    fn file_metadata(&self, file: &str) -> Result<libpijul::pristine::InodeMetadata, Self::Error> {
        self.working_copy.file_metadata(file)
    }
    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {
        match self.open_files.get(Utf8Path::new(file)) {
            Some(open_file) => buffer.extend(open_file.contents.text.bytes()),
            None => self.working_copy.read_file(file, buffer)?,
        }
        Ok(())
    }
    fn modified_time(&self, file: &str) -> Result<std::time::SystemTime, Self::Error> {
        match self.open_files.get(Utf8Path::new(file)) {
            Some(open_file) => Ok(open_file.contents.modified_time),
            None => self.working_copy.modified_time(file),
        }
    }
}

use std::ops::RangeInclusive;
use camino::Utf8PathBuf;
use libpijul::ArcTxn;
use libpijul::ChannelRef;
use libpijul::TxnTExt;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::InodeMetadata;
use libpijul::pristine::sanakirja::MutTxn;
use libpijul::pristine::sanakirja::SanakirjaError;
use libpijul::working_copy::WorkingCopyRead;
use crate::file_system::changes::CreditSource;
use crate::file_system::changes::FileCredits;
use crate::file_system::changes::FileCreditsError;
use crate::file_system::changes::Span;
use crate::file_system::changes::unrecorded::UnrecordedChangesError;
use crate::file_system::open_file::contents::FileContents;
pub mod contents;
#[derive(Debug, thiserror::Error)]
pub enum OpenFileError<C: std::error::Error + 'static> {
    #[error("failed to check if {path} is tracked: {error:#?}")]
    CheckIfTracked {
        path: Utf8PathBuf,
        error: SanakirjaError,
    },
    #[error(transparent)]
    FileChanges(#[from] UnrecordedChangesError<C>),
    #[error(transparent)]
    TrackedFile(#[from] FileCreditsError<C>),
}
#[derive(Clone, Debug)]
pub struct OpenFile {
    pub contents: FileContents,
    pub credits: Option<FileCredits>,
}
impl OpenFile {
    pub fn open<C, W>(
        path: Utf8PathBuf,
        file_contents: String,
        metadata: InodeMetadata,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
        working_copy: &W,
    ) -> Result<Self, OpenFileError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
        W: WorkingCopyRead,
    {
        let contents = FileContents::new(path.clone(), metadata, file_contents, working_copy);
        let credits = if transaction
            .read()
            .is_tracked(path.as_str())
            .map_err(|error| OpenFileError::CheckIfTracked { path, error })?
        {
            Some(FileCredits::new(
                &contents,
                transaction,
                channel,
                change_store,
            )?)
        } else {
            None
        };
        Ok(Self { contents, credits })
    }
    pub fn update<C>(
        &mut self,
        character_offset: usize,
        characters_replaced: usize,
        replacement_text: &str,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<(), UnrecordedChangesError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        if characters_replaced > 0 {
            self.contents
                .text
                .remove(character_offset..(character_offset + characters_replaced));
        }
        if !replacement_text.is_empty() {
            self.contents
                .text
                .insert(character_offset, replacement_text);
        }
        if let Some(credits) = &mut self.credits {
            // TODO: only re-compute spans that were affected
            credits.recompute_spans(&self.contents, transaction, channel, change_store)?;
        }
        Ok(())
    }
    pub fn credit(&self, lines: RangeInclusive<usize>) -> Vec<Span<CreditSource>> {
        match &self.credits {
            Some(credits) => credits.spans_within_lines(lines).collect(),
            None => Vec::from([Span {
                value: CreditSource::Untracked,
                lines,
            }]),
        }
    }
    pub fn tracked_contents(&self) -> String {
        self.contents.text.to_string()
    }
}

use std::time::SystemTime;
use camino::Utf8PathBuf;
use libpijul::pristine::InodeMetadata;
use libpijul::working_copy::WorkingCopyRead;
use ropey::Rope;
#[derive(Debug, thiserror::Error)]
pub enum FileContentsError {
    #[error("Invalid path: expected {expected_path:?}, got {incorrect_path:?}")]
    InvalidPath {
        expected_path: Utf8PathBuf,
        incorrect_path: Utf8PathBuf,
    },
}
#[derive(Clone, Debug)]
pub struct FileContents {
    // TODO: path shouldn't be stored here
    pub path: Utf8PathBuf,
    pub metadata: InodeMetadata,
    pub modified_time: SystemTime,
    pub text: Rope,
}
impl FileContents {
    pub fn new<W: WorkingCopyRead>(
        path: Utf8PathBuf,
        metadata: InodeMetadata,
        contents: String,
        working_copy: &W,
    ) -> Self {
        let last_modified_time = working_copy
            .modified_time(path.as_str())
            .unwrap_or(SystemTime::now());
        Self {
            path,
            metadata,
            modified_time: last_modified_time,
            text: Rope::from(contents),
        }
    }
}
// TODO: implement `WorkingCopyRead` for `EditorWorkingCopy` instead?
impl WorkingCopyRead for FileContents {
    type Error = FileContentsError;
    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, Self::Error> {
        if file != self.path.as_str() {
            return Err(FileContentsError::InvalidPath {
                expected_path: self.path.clone(),
                incorrect_path: Utf8PathBuf::from(file),
            });
        }
        Ok(self.metadata)
    }
    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {
        if file != self.path.as_str() {
            return Err(FileContentsError::InvalidPath {
                expected_path: self.path.clone(),
                incorrect_path: Utf8PathBuf::from(file),
            });
        }
        buffer.extend(self.text.bytes());
        Ok(())
    }
    fn modified_time(&self, file: &str) -> Result<SystemTime, Self::Error> {
        if file != self.path.as_str() {
            return Err(FileContentsError::InvalidPath {
                expected_path: self.path.clone(),
                incorrect_path: Utf8PathBuf::from(file),
            });
        }
        Ok(self.modified_time)
    }
}

pub mod changes;
pub mod open_file;
pub mod working_copy;

use libpijul::change::{Atom, BaseHunk, TextSerError};
use libpijul::changestore::ChangeStore;
use libpijul::pristine::sanakirja::{MutTxn, SanakirjaError};
use libpijul::{ArcTxn, ChannelRef, RecordBuilder};
use crate::file_system::changes::Span;
use crate::file_system::open_file::contents::{FileContents, FileContentsError};
#[derive(Debug, thiserror::Error)]
#[error(transparent)]
pub enum UnrecordedChangesError<C: std::error::Error + 'static> {
    ChangeContents(#[from] TextSerError<C>),
    Globalize(#[from] SanakirjaError),
    Record(#[from] libpijul::record::RecordError<C, FileContentsError, MutTxn<()>>),
}
#[derive(Clone, Copy, Debug)]
pub enum SpanKind {
    Replacement {
        old_line_count: usize,
        new_line_count: usize,
    },
    Addition {
        lines_added: usize,
    },
    Deletion {
        lines_removed: usize,
    },
}
#[derive(Clone, Debug)]
pub struct UnrecordedChanges {
    pub spans: Vec<Span<SpanKind>>,
}
impl UnrecordedChanges {
    pub fn new<C>(
        file: &FileContents,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<Self, UnrecordedChangesError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        let mut unrecorded_changes = RecordBuilder::new();
        unrecorded_changes.record(
            transaction.clone(),
            libpijul::Algorithm::default(),
            false, // TODO: check and document
            &libpijul::DEFAULT_SEPARATOR,
            channel.clone(),
            file,
            change_store,
            file.path.as_str(),
            1, // TODO: figure out concurrency model
        )?;
        let unrecorded_state = unrecorded_changes.finish();
        let change_contents = unrecorded_state.contents.lock();
        let mut unrecorded_spans = Vec::new();
        // TODO: handle encoding
        for hunk in unrecorded_state.actions {
            let globalized_hunk = hunk.globalize(&*transaction.read())?;
            match globalized_hunk {
                BaseHunk::Replacement {
                    change,
                    replacement,
                    local,
                    encoding,
                } => {
                    let old_contents = libpijul::change::get_change_contents(
                        change_store,
                        &change,
                        &change_contents,
                    )?;
                    let new_contents = libpijul::change::get_change_contents(
                        change_store,
                        &replacement,
                        &change_contents,
                    )?;
                    let old_text = String::from_utf8(old_contents).unwrap();
                    let new_text = String::from_utf8(new_contents).unwrap();
                    let old_line_count = old_text.lines().count().strict_sub(1);
                    let new_line_count = new_text.lines().count().strict_sub(1);
                    let span_start = local.line - 1;
                    unrecorded_spans.push(Span {
                        value: SpanKind::Replacement {
                            old_line_count,
                            new_line_count,
                        },
                        lines: span_start..=span_start.strict_add(new_line_count),
                    });
                }
                BaseHunk::Edit {
                    change,
                    local,
                    encoding,
                } => {
                    let new_contents = libpijul::change::get_change_contents(
                        change_store,
                        &change,
                        &change_contents,
                    )?;
                    let text = String::from_utf8(new_contents).unwrap();
                    let line_count = text.lines().count();
                    let span_start = local.line - 1;
                    // Skip deletions as they don't contribute any spans
                    let span = if let Atom::EdgeMap(edge) = change
                        && (edge.edges.is_empty() || edge.edges[0].flag.is_deleted())
                    {
                        Span {
                            value: SpanKind::Deletion {
                                lines_removed: line_count,
                            },
                            lines: span_start..=span_start,
                        }
                    } else {
                        Span {
                            value: SpanKind::Addition {
                                lines_added: line_count,
                            },
                            lines: span_start..=(span_start + line_count - 1),
                        }
                    };
                    unrecorded_spans.push(span);
                }
                // TODO: handle conflict resolution
                // TODO: handle moves
                _ => {
                    tracing::warn!(message = "Skipping unrecorded hunk", ?globalized_hunk);
                }
            }
        }
        unrecorded_spans.sort_by_key(|span| *span.lines.start());
        Ok(Self {
            spans: unrecorded_spans,
        })
    }
}

use std::ops::RangeInclusive;
use std::sync::OnceLock;
use camino::Utf8Path;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::sanakirja::{MutTxn, SanakirjaError};
use libpijul::vertex_buffer::VertexBuffer;
use libpijul::{ArcTxn, ChangeId, ChannelRef, TxnTExt, Vertex};
use crate::file_system::changes::{CreditSource, Span};
#[derive(Debug, thiserror::Error)]
pub enum RecordedStateError<C: std::error::Error + 'static> {
    #[error("unable to find oldest vertex: {0:#?}")]
    OldestVertex(#[from] libpijul::fs::FsErrorC<C, MutTxn<()>>),
    #[error("unable to output file: {0:#?}")]
    OutputFile(#[from] libpijul::output::FileError<C, MutTxn<()>>),
    #[error("unable to get external hash for {change_id:#?}")]
    ExternalHash {
        change_id: libpijul::pristine::ChangeId,
        error: libpijul::pristine::TxnErr<SanakirjaError>,
    },
    #[error("no matching external hash for change ID: {0:#?}")]
    MissingExternalHash(libpijul::pristine::ChangeId),
    #[error("unable to get hash from changestore: {0:#?}")]
    ChangeStore(C),
}
// TODO: reference diff::vertex_buffer::Diff file:///home/finchie/Projects/Pijul/pijul/target/doc/libpijul/diff/vertex_buffer/struct.Diff.html
struct ChangesBuffer {
    introduced_by: OnceLock<ChangeId>,
    original_contents: String,
    spans: Vec<Span<ChangeId>>,
}
// TODO: don't assume encoding
#[derive(Clone, Debug)]
pub struct RecordedState {
    pub introduced_by: ChangeId,
    pub original_contents: String,
    pub spans: Vec<Span<ChangeId>>,
}
impl RecordedState {
    pub fn new<C>(
        path: &Utf8Path,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<Self, RecordedStateError<C::Error>>
    where
        C: ChangeStore,
    {
        // TODO: handle ambiguity (possibly when there is a path conflict?)
        let (oldest_vertex, _ambiguous) =
            transaction
                .read()
                .follow_oldest_path(change_store, channel, path.as_str())?;
        let mut changes_buffer = ChangesBuffer {
            introduced_by: OnceLock::new(),
            original_contents: String::new(),
            spans: Vec::new(),
        };
        libpijul::output::output_file(
            change_store,
            transaction,
            channel,
            oldest_vertex,
            &mut changes_buffer,
        )?;
        Ok(Self {
            introduced_by: changes_buffer.introduced_by.take().unwrap(),
            original_contents: changes_buffer.original_contents,
            spans: changes_buffer.spans,
        })
    }
    pub fn spans_within_lines(
        &self,
        untracked_line_range: RangeInclusive<usize>,
        offset: isize,
    ) -> impl Iterator<Item = Span<CreditSource>> {
        let tracked_line_range = untracked_line_range.start().strict_add_signed(offset)
            ..=untracked_line_range.end().strict_add_signed(offset);
        Span::spans_within_lines(&self.spans, tracked_line_range).map(move |span| Span {
            value: CreditSource::Tracked(span.value),
            lines: (span.lines.start().strict_sub_signed(offset))
                ..=(span.lines.end().strict_sub_signed(offset)),
        })
    }
}
impl VertexBuffer for ChangesBuffer {
    fn output_line<E, F>(&mut self, vertex: Vertex<ChangeId>, contents: F) -> Result<(), E>
    where
        E: From<std::io::Error>,
        F: FnOnce(&mut [u8]) -> Result<(), E>,
    {
        // The first "line" output is an empty line representing the change that introduced the file
        if self.introduced_by.get().is_none() {
            self.introduced_by.set(vertex.change).unwrap();
            assert!(vertex.is_empty());
            return Ok(());
        }
        // The final "line" output is an empty line with an empty change ID
        if vertex.change.0.as_u64() == 0 {
            return Ok(());
        }
        assert!(!vertex.is_empty());
        assert!(!vertex.is_root());
        let mut buffer = vec![0; vertex.end - vertex.start];
        contents(&mut buffer)?;
        let contents = String::from_utf8(buffer).unwrap();
        // Keep track of the original contents
        self.original_contents.push_str(&contents);
        // Add the starting line and line count of the contents affected by this change ID
        let start_line = match self.spans.last() {
            Some(previous_span) => previous_span.next_span_start(),
            None => 0,
        };
        let length = contents.lines().count();
        self.spans.push(Span {
            value: vertex.change,
            lines: start_line..=(start_line + length - 1),
        });
        Ok(())
    }
    // TODO: handle all the conflict markers independently
    fn output_conflict_marker<C: libpijul::changestore::ChangeStore>(
        &mut self,
        s: &str,
        id: usize,
        sides: Option<(&C, &[&libpijul::Hash])>,
    ) -> Result<(), std::io::Error> {
        todo!("Conflict markers")
    }
}

use std::ops::RangeInclusive;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::sanakirja::MutTxn;
use libpijul::{ArcTxn, ChangeId, ChannelRef};
use crate::file_system::changes::recorded::RecordedStateError;
use crate::file_system::changes::unrecorded::UnrecordedChangesError;
use crate::file_system::open_file::contents::FileContents;
pub mod recorded;
pub mod unrecorded;
#[derive(Clone, Debug)]
pub struct Span<T: std::fmt::Debug> {
    pub value: T,
    pub lines: RangeInclusive<usize>,
}
impl<T: Clone + std::fmt::Debug> Span<T> {
    pub fn next_span_start(&self) -> usize {
        self.lines.end() + 1
    }
    pub fn spans_within_lines(
        spans: &[Self],
        line_range: RangeInclusive<usize>,
    ) -> impl Iterator<Item = Self> {
        debug_assert!(
            line_range.start() <= line_range.end(),
            "Invalid range: {line_range:#?}"
        );
        debug_assert!(spans.is_sorted_by_key(|span| span.lines.start()));
        let lines_start = *line_range.start();
        let lines_end = *line_range.end();
        spans
            .iter()
            .skip_while(move |span| *span.lines.end() < lines_start)
            .take_while(move |span| *span.lines.start() <= lines_end)
            .filter_map(move |span| {
                let span_start = *span.lines.start().max(&lines_start);
                let span_end = *span.lines.end().min(&lines_end);
                if span_end >= span_start {
                    Some(Span {
                        value: span.value.clone(),
                        lines: span_start..=span_end,
                    })
                } else {
                    None
                }
            })
    }
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CreditSource {
    Tracked(ChangeId),
    Untracked,
}
#[derive(Debug, thiserror::Error)]
pub enum FileCreditsError<C: std::error::Error + 'static> {
    #[error("unable to get tracked file state: {0:?}")]
    TrackedState(#[from] RecordedStateError<C>),
    #[error("unable to get untracked changes: {0:?}")]
    UntrackedChanges(#[from] UnrecordedChangesError<C>),
}
#[derive(Clone, Debug)]
pub struct FileCredits {
    pub recorded_state: recorded::RecordedState,
    pub spans: Vec<Span<CreditSource>>,
}
impl FileCredits {
    pub fn new<C>(
        file: &FileContents,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<Self, FileCreditsError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        let state = recorded::RecordedState::new(&file.path, transaction, channel, change_store)?;
        let mut tracked_file = Self {
            recorded_state: state,
            spans: Vec::new(),
        };
        tracked_file.recompute_spans(file, transaction, channel, change_store)?;
        Ok(tracked_file)
    }
    pub fn recompute_spans<C>(
        &mut self,
        file: &FileContents,
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<(), UnrecordedChangesError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        let untracked_changes =
            unrecorded::UnrecordedChanges::new(file, transaction, channel, change_store)?;
        let mut merged_spans = Vec::new();
        let mut untracked_spans = untracked_changes.spans.iter().peekable();
        let mut current_offset: isize = 0;
        let mut incomplete_span_start: Option<usize> = Some(0);
        while let Some(untracked_span) = untracked_spans.next() {
            if let Some(incomplete_span_start) = incomplete_span_start.take()
                && *untracked_span.lines.start() > incomplete_span_start
            {
                merged_spans.extend(self.recorded_state.spans_within_lines(
                    incomplete_span_start..=(untracked_span.lines.start().strict_sub(1)),
                    current_offset,
                ));
            }
            match untracked_span.value {
                unrecorded::SpanKind::Replacement {
                    old_line_count,
                    new_line_count,
                } => {
                    merged_spans.push(Span {
                        value: CreditSource::Untracked,
                        lines: untracked_span.lines.clone(),
                    });
                    let replacement_line_offset =
                        (new_line_count as isize).strict_add_unsigned(old_line_count);
                    current_offset = current_offset.strict_add(replacement_line_offset);
                }
                unrecorded::SpanKind::Addition { lines_added } => {
                    merged_spans.push(Span {
                        value: CreditSource::Untracked,
                        lines: untracked_span.lines.clone(),
                    });
                    current_offset = current_offset.strict_sub_unsigned(lines_added);
                }
                unrecorded::SpanKind::Deletion { lines_removed } => {
                    // Deletions don't contribute any spans, only change the offset
                    // to skip the deleted lines.
                    current_offset = current_offset.strict_add_unsigned(lines_removed);
                    incomplete_span_start = Some(*untracked_span.lines.start());
                }
            }
            if let Some(next_untracked_span) = untracked_spans.peek()
                && *next_untracked_span.lines.start() > untracked_span.next_span_start()
            {
                merged_spans.extend(self.recorded_state.spans_within_lines(
                    untracked_span.next_span_start()..=(next_untracked_span.lines.start() - 1),
                    current_offset,
                ));
            }
        }
        let file_length = file.text.len_lines(ropey::LineType::LF_CR).strict_sub(1);
        if let Some(final_span) = merged_spans.last()
            && *final_span.lines.end() < file_length.strict_sub(1)
        {
            merged_spans.extend(self.recorded_state.spans_within_lines(
                (final_span.lines.end() + 1)..=file_length.strict_sub(1),
                current_offset,
            ));
        }
        if merged_spans.is_empty() {
            merged_spans.extend(
                self.recorded_state
                    .spans_within_lines(0..=file_length.strict_sub(1), 0),
            );
        }
        // If the final line ends in a newline, text editors will allow selecting the "next line"
        // For example: `Line 1\nLine 2\n` will be rendered as:
        // ```
        // Line 1
        // Line 2
        //
        // ```
        // So extend the span of line 2 (index 1) to include this empty line
        if let Some(final_span) = merged_spans.last_mut()
            && let Some(final_character) = file.text.chars().last()
            && final_character == '\n'
        {
            let start_line = *final_span.lines.start();
            let end_line = *final_span.lines.end();
            final_span.lines = start_line..=(end_line + 1);
        }
        // Check the spans were generated correctly
        if cfg!(debug_assertions) {
            let mut span_windows = merged_spans.windows(2);
            // Span ranges must be in order
            while let Some([first, second]) = span_windows.next() {
                assert_eq!(
                    first.lines.end() + 1,
                    *second.lines.start(),
                    "Invalid span ranges: {merged_spans:#?}"
                )
            }
            // Entire file is covered
            let last_span_line = merged_spans
                .last()
                .map(|span| *span.lines.end())
                .unwrap_or(0);
            let last_text_lines = file.text.len_lines(ropey::LineType::LF_CR) - 1;
            assert_eq!(
                last_span_line, last_text_lines,
                "Incorrect span end (got {last_span_line}, expected {last_text_lines}): {merged_spans:#?}"
            );
        }
        // Combine consecutive spans of the same type into a single span
        merged_spans =
            merged_spans
                .into_iter()
                .fold(Vec::new(), |mut previous_spans, current_span| {
                    if let Some(previous_span) = previous_spans.last_mut()
                        && previous_span.value == current_span.value
                    {
                        let previous_start = *previous_span.lines.start();
                        previous_span.lines = previous_start..=*current_span.lines.end();
                    } else {
                        previous_spans.push(current_span);
                    }
                    previous_spans
                });
        self.spans = merged_spans;
        Ok(())
    }
    // TODO: check that range is within limits?
    pub fn spans_within_lines(
        &self,
        line_range: RangeInclusive<usize>,
    ) -> impl Iterator<Item = Span<CreditSource>> {
        Span::spans_within_lines(&self.spans, line_range)
    }
}

use std::cell::OnceCell;
use std::collections::HashMap;
use libpijul::change::ChangeHeader;
use libpijul::changestore::ChangeStore;
use libpijul::pristine::TxnErr;
use libpijul::pristine::sanakirja::{MutTxn, SanakirjaError};
use libpijul::{ArcTxn, ChangeId, ChannelRef, GraphTxnT, TxnTExt};
#[derive(Debug, thiserror::Error)]
pub enum ChannelStateError<C: std::error::Error + 'static> {
    #[error("unable to iterate changes: {0:#?}")]
    ReverseLog(SanakirjaError),
    #[error("encountered error while iterating log: {0:#?}")]
    Item(SanakirjaError),
    #[error("unable to get external hash: {0:#?}")]
    InternalHash(TxnErr<SanakirjaError>),
    #[error("unable to read changes: {0:#?}")]
    ChangeStore(C),
}
pub struct ChannelState {
    root_change: ChangeId,
    changes: HashMap<ChangeId, ChangeHeader>,
}
impl ChannelState {
    pub fn new<C>(
        transaction: &ArcTxn<MutTxn<()>>,
        channel: &ChannelRef<MutTxn<()>>,
        change_store: &C,
    ) -> Result<Self, ChannelStateError<C::Error>>
    where
        C: ChangeStore + Clone + Send + 'static,
    {
        let mut changes = HashMap::new();
        let mut root_change = OnceCell::new();
        // TODO: authors
        // let mut authors = HashSet::new();
        let read_transaction = transaction.read();
        let mut reverse_log = read_transaction
            .reverse_log(&*channel.read(), None)
            .map_err(ChannelStateError::ReverseLog)?
            .peekable();
        while let Some(log_result) = reverse_log.next() {
            // TODO: merkle
            let (_, (hash, merkle)) = log_result.map_err(ChannelStateError::Item)?;
            let change_id = *read_transaction
                .get_internal(hash)
                .map_err(ChannelStateError::InternalHash)?
                .unwrap();
            // TODO: `change_id.is_root()` is broken?
            if reverse_log.peek().is_none() {
                root_change.set(change_id).unwrap();
            } else {
                let change_header = change_store
                    .get_header(&hash.into())
                    .map_err(ChannelStateError::ChangeStore)?;
                dbg!(&change_header.authors);
                changes.try_insert(change_id, change_header).unwrap();
            }
        }
        Ok(ChannelState {
            root_change: root_change.take().unwrap(),
            changes,
        })
    }
    pub fn get_change_header(&self, change_id: &ChangeId) -> Option<&ChangeHeader> {
        self.changes.get(change_id)
    }
    pub fn iter_change_headers(&self) -> impl Iterator<Item = &ChangeHeader> {
        self.changes.values()
    }
}

use std::collections::HashMap;
use std::collections::hash_map::Entry;
use std::fs::File;
use camino::Utf8Path;
use libpijul::change::ChangeHeader;
use crate::channel_state::ChannelState;
#[derive(Clone, Debug)]
pub enum AuthorSource {
    Local(pijul_identity::Complete),
    Remote(pijul_identity::Complete),
    Unknown(String),
}
pub struct Authors {
    authors: HashMap<String, AuthorSource>,
}
impl Authors {
    pub fn new(channel_state: &ChannelState, dot_directory: &Utf8Path) -> Self {
        let mut authors = HashMap::new();
        let repository_identities_path = dot_directory.join("identities");
        match pijul_identity::Complete::load_all() {
            Ok(local_identities) => {
                for local_identity in local_identities {
                    let public_key_signature = local_identity.public_key.key.clone();
                    match authors.entry(public_key_signature.clone()) {
                        Entry::Occupied(occupied_entry) => {
                            tracing::error!(
                                message = "Duplicate local identities found",
                                public_key_signature,
                                previous_author = ?occupied_entry.get(),
                            );
                        }
                        Entry::Vacant(vacant_entry) => {
                            vacant_entry.insert(AuthorSource::Local(local_identity));
                        }
                    }
                }
            }
            Err(error) => tracing::error!(message = "Unable to load local identities", ?error),
        }
        for change_header in channel_state.iter_change_headers() {
            for serialized_author in &change_header.authors {
                match serialized_author.0.get("key") {
                    Some(public_key_signature) => {
                        if let Entry::Vacant(vacant_entry) =
                            authors.entry(public_key_signature.to_owned())
                        {
                            // Try to read from `.pijul/identities/{public_key_signature}`
                            let identity_path =
                                repository_identities_path.join(public_key_signature);
                            let author_source = match File::open(&identity_path) {
                                Ok(identity_file) => match serde_json::from_reader(identity_file) {
                                    Ok(remote_identity) => AuthorSource::Remote(remote_identity),
                                    Err(error) => {
                                        tracing::error!(
                                            message = "Failed to deserialize identity file",
                                            ?identity_path,
                                            ?error
                                        );
                                        AuthorSource::Unknown(public_key_signature.to_owned())
                                    }
                                },
                                Err(error) => {
                                    tracing::error!(
                                        message = "Failed to open identity file",
                                        ?identity_path,
                                        ?error
                                    );
                                    AuthorSource::Unknown(public_key_signature.to_owned())
                                }
                            };
                            vacant_entry.insert(author_source);
                        }
                    }
                    None => {
                        tracing::warn!(message = "Author missing `key` field", ?serialized_author);
                    }
                }
            }
        }
        Self { authors }
    }
    pub fn authors_for_change(&self, change_header: &ChangeHeader) -> Vec<&AuthorSource> {
        let mut authors = Vec::new();
        for serialized_author in &change_header.authors {
            match serialized_author.0.get("key") {
                Some(public_key_signature) => match self.authors.get(public_key_signature) {
                    Some(author) => {
                        authors.push(author);
                    }
                    None => tracing::error!(
                        message = "No matching author for key",
                        public_key_signature,
                        ?change_header
                    ),
                },
                None => {
                    tracing::warn!(message = "Author missing `key` field", ?serialized_author);
                }
            }
        }
        authors
    }
}

[package]
name = "pijul-extension"
version = "0.1.0"
edition = "2024"
[dependencies]
camino.workspace = true
canonical-path.workspace = true
libpijul.workspace = true
path-slash.workspace = true
pijul-identity.workspace = true
ropey.workspace = true
serde_json.workspace = true
thiserror.workspace = true
tracing.workspace = true

{
	"compilerOptions": {
		"module": "Node16",
		"target": "ES2022",
		"outDir": "out",
		"lib": ["ES2022"],
		"sourceMap": true,
		"rootDir": "src",
		"strict": true /* enable all strict type-checking options */
		/* Additional Checks */
		// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
		// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
		// "noUnusedParameters": true,  /* Report errors on unused parameters. */
	}
}

use napi::bindgen_prelude;
use napi::bindgen_prelude::JsObjectValue;
use super::macros::{event_handler, namespace_field_getter, namespace_function, register_provider};
use super::{
    TextDocument, TextDocumentChangeEvent, TextDocumentContentProvider, Uri, WorkspaceFolder,
    WorkspaceFoldersChangeEvent,
};
event_handler!(
    "workspace",
    "onDidChangeTextDocument",
    on_did_change_text_document(TextDocumentChangeEvent)
);
event_handler!(
    "workspace",
    "onDidChangeWorkspaceFolders",
    on_did_change_workspace_folders(WorkspaceFoldersChangeEvent)
);
namespace_field_getter! {
    "workspace" {
        "textDocuments": get_text_documents -> Vec<TextDocument<'env>>;
        "workspaceFolders": get_workspace_folders -> Vec<WorkspaceFolder<'env>>;
    }
}
namespace_function! {
    "workspace" {
        "getWorkspaceFolder":
            get_workspace_folder(
                uri: &Uri,
            ) -> Option<WorkspaceFolder<'env>>;
    }
}
register_provider!(
    "workspace",
    "registerTextDocumentContentProvider",
    register_text_document_content_provider(scheme: &str, provider: TextDocumentContentProvider<'env>)
);

use napi::bindgen_prelude;
use napi::bindgen_prelude::JsObjectValue;
use super::macros::{event_handler, namespace_field_getter, namespace_function, register_provider};
use super::{
    DecorationRenderOptions, FileDecorationProvider, TextEditor, TextEditorDecorationType,
    TextEditorSelectionChangeEvent,
};
event_handler!(
    "window",
    "onDidChangeTextEditorSelection",
    on_did_change_text_editor_selections(TextEditorSelectionChangeEvent)
);
event_handler!(
    "window",
    "onDidChangeVisibleTextEditors",
    on_did_change_visible_text_editors(Vec<TextEditor>)
);
namespace_field_getter! {
    "window" {
        "activeTextEditor": get_active_text_editor -> Option<TextEditor<'env>>;
        "visibleTextEditors": get_visible_text_editors -> Vec<TextEditor<'env>>;
    }
}
namespace_function! {
    "window" {
        "createTextEditorDecorationType":
            create_text_editor_decoration_type(
                render_options: DecorationRenderOptions,
            ) -> TextEditorDecorationType<'env>;
    }
}
register_provider!("window", "registerFileDecorationProvider", register_file_decoration_provider(provider: FileDecorationProvider));
pub fn create_log_output_channel<'env>(
    env: &napi::Env,
    name: &str,
) -> Result<bindgen_prelude::Object<'env>, napi::Error> {
    let vscode_object = super::VscodeContext::vscode(env)?;
    let window: bindgen_prelude::Object = vscode_object.get_named_property("window")?;
    let function_prototype: bindgen_prelude::Function<
        bindgen_prelude::FnArgs<(&str, bindgen_prelude::Object)>,
        bindgen_prelude::Object,
    > = window.get_named_property("createOutputChannel")?;
    let mut options = bindgen_prelude::Object::new(env)?;
    options.set_named_property("log", true)?;
    let output_channel =
        function_prototype.apply(window, bindgen_prelude::FnArgs::from((name, options)))?;
    Ok(output_channel)
}

use napi::bindgen_prelude;
use napi::bindgen_prelude::JsObjectValue;
use super::macros::namespace_function;
use super::{SourceControl, Uri};
namespace_function! {
    "scm" {
        "createSourceControl":
            create_source_control(
                id: &str,
                label: &str,
                root_uri: &Uri,
            ) -> SourceControl<'env>;
    }
}

use napi::bindgen_prelude;
use super::macros::object_reference;
use super::{SourceControl, SourceControlResourceGroup, TextEditor, TextEditorDecorationType};
object_reference!(SourceControlRef: SourceControl);
object_reference!(SourceControlResourceGroupRef: SourceControlResourceGroup);
object_reference!(TextEditorRef: TextEditor);
object_reference!(TextEditorDecorationTypeRef: TextEditorDecorationType);

// TODO: `FromNapiValue` should also validate
// TODO: either completely remove/embrace `FnArgs`
use std::sync::MappedMutexGuard;
use std::sync::{Mutex, MutexGuard, OnceLock};
use napi::JsValue;
use napi::bindgen_prelude;
use napi::bindgen_prelude::{
    FromNapiValue, JsObjectValue, ToNapiValue, TypeName, ValidateNapiValue,
};
use napi_sys::{napi_env, napi_value};
use macros::{
    class_wrapper, empty_function_caller, field_getter, field_setter, function_caller,
    function_setter, interface_builder, static_class_method,
};
// Internal/helper modules
pub mod log;
mod macros;
pub mod reference;
// VSCode API namespaces
pub mod scm;
pub mod window;
pub mod workspace;
static CONTEXT: Mutex<OnceLock<VscodeContext>> = Mutex::new(OnceLock::new());
struct VscodeContext {
    vscode: bindgen_prelude::ObjectRef,
    extension_context: bindgen_prelude::ObjectRef,
}
impl VscodeContext {
    fn inner() -> Result<MappedMutexGuard<'static, Self>, napi::Error> {
        let mutex_guard = CONTEXT.lock().map_err(|_error| {
            napi::Error::from_reason("vscode_sys::Context mutex has been poisoned")
        })?;
        MutexGuard::filter_map(mutex_guard, |guarded_value| match guarded_value.get_mut() {
            Some(vscode_context) => Some(vscode_context),
            None => None,
        })
        .map_err(|_empty_guard| {
            napi::Error::new(napi::Status::GenericFailure, "`vscode` object is not set")
        })
    }
    fn extension_context<'env>(
        env: &'env napi::Env,
    ) -> Result<bindgen_prelude::Object<'env>, napi::Error> {
        let context = Self::inner()?;
        context.extension_context.get_value(env)
    }
    fn vscode<'env>(env: &'env napi::Env) -> Result<bindgen_prelude::Object<'env>, napi::Error> {
        let context = Self::inner()?;
        context.vscode.get_value(env)
    }
}
pub fn activate(
    vscode_object: &bindgen_prelude::Object,
    extension_context: &bindgen_prelude::Object,
) -> Result<(), napi::Error> {
    let mutex_guard = CONTEXT.lock().map_err(|_error| {
        napi::Error::from_reason(
            "vscode_sys::Context mutex was poisoned before it could be initialized",
        )
    })?;
    let context = VscodeContext {
        vscode: vscode_object.create_ref()?,
        extension_context: extension_context.create_ref()?,
    };
    mutex_guard.set(context).map_err(|_error| {
        napi::Error::from_reason(
            "`activate()` has already been called, but must be called exactly once",
        )
    })?;
    Ok(())
}
class_wrapper!(FileDecoration(badge: &str, tooltip: &str, color: &ThemeColor));
class_wrapper!(MarkdownString(value: &str, support_theme_icons: bool));
class_wrapper!(Position(line: u32, character: u32));
field_getter! {
    Position {
        "line": get_line -> u32;
    }
}
class_wrapper!(Range(start: &Position<'env>, end: &Position<'env>));
class_wrapper!(Selection(anchor: &Position<'env>, active: &Position<'env>));
field_getter! {
    Selection {
        "start": get_start -> Position<'env>;
        "end": get_end -> Position<'env>;
    }
}
class_wrapper!(ThemeColor(id: &str));
// TODO: private constructor
class_wrapper!(Uri(scheme: &str, authority: &str, path: &str, query: &str, fragment: &str));
field_getter! {
    Uri {
        "fsPath": get_fs_path -> String;
        "scheme": get_scheme -> String;
    }
}
empty_function_caller! {
    Uri {
        "toString":
            to_string() -> String;
    }
}
function_caller! {
    Uri {
        "with":
            with(
                change: UriWithChange,
            ) -> Uri<'env>;
    }
}
static_class_method! {
    Uri {
        "file":
            file(
                path: &str,
            ) -> Uri<'env>;
    }
}
interface_builder! {
    DecorationOptions {
        ("range": Range, range: &Range),
    }
    ("hoverMessage", hover_message: &MarkdownString),
    ("renderOptions", render_options: DecorationInstanceRenderOptions),
}
interface_builder! {
    DecorationInstanceRenderOptions {}
    ("after", after: ThemableDecorationAttachmentRenderOptions),
}
interface_builder! {
    DecorationRenderOptions {}
    ("after", after: ThemableDecorationAttachmentRenderOptions),
}
interface_builder! {
    FileDecorationProvider {
        F: set_provide_file_decoration =
            provide_file_decoration(
                uri: Uri,
                cancellation_token: bindgen_prelude::Object
            ) -> FileDecoration<'function_context>;
    }
}
function_setter! {
    FileDecorationProvider {
        "provideFileDecoration" {
            set_provide_file_decoration(
                uri: Uri,
                cancellation_token: bindgen_prelude::Object
            ) -> FileDecoration<'function_context>;
            bindgen_prelude::ObjectRef = |returned_result: Option<FileDecoration>| returned_result.map(|object| object.inner.create_ref()).transpose();
        }
    }
}
interface_builder! {
    QuickDiffProvider {}
}
function_setter! {
    QuickDiffProvider {
        "provideOriginalResource" {
            set_provide_original_resource(
                uri: Uri<'function_context>,
                cancellation_token: bindgen_prelude::Object<'function_context>
            ) -> Uri<'function_context>;
            bindgen_prelude::ObjectRef = |returned_result: Option<Uri>| returned_result.map(|object| object.inner.create_ref()).transpose();
        }
    }
}
interface_builder! {
    SourceControl {}
}
field_setter! {
    SourceControl {
        "quickDiffProvider": set_quick_diff_provider(QuickDiffProvider);
    }
}
function_caller! {
    SourceControl {
        "createResourceGroup":
            create_resource_group(
                id: &str,
                label: &str,
            ) -> SourceControlResourceGroup<'env>;
    }
}
interface_builder! {
    SourceControlResourceGroup {}
}
field_setter! {
    SourceControlResourceGroup {
        "resourceStates": set_resource_states(Vec<SourceControlResourceState>);
    }
}
interface_builder! {
    SourceControlResourceState {
        ("resourceUri": Uri, resource_uri: &Uri),
    }
}
interface_builder! {
    TextDocument {}
}
field_getter! {
    TextDocument {
        "uri": get_uri -> Uri<'env>;
    }
}
function_caller! {
    TextDocument {
        "getText":
            get_text(
                range: Option<Range>,
            ) -> String;
    }
}
interface_builder! {
    TextDocumentChangeEvent {}
}
field_getter! {
    TextDocumentChangeEvent {
        "document": get_document -> TextDocument<'env>;
        "contentChanges": get_content_changes -> Vec<TextDocumentContentChangeEvent<'env>>;
    }
}
interface_builder! {
    TextDocumentContentChangeEvent {}
}
field_getter! {
    TextDocumentContentChangeEvent {
        "rangeOffset": get_range_offset -> u32;
        "rangeLength": get_range_length -> u32;
        "text": get_text -> String;
    }
}
interface_builder! {
    TextDocumentContentProvider {
        F: set_provide_text_document_content =
            provide_text_document_content(
                uri: Uri<'function_context>,
                cancellation_token: bindgen_prelude::Object<'function_context>
            ) -> String;
    }
}
function_setter! {
    TextDocumentContentProvider {
        "provideTextDocumentContent" {
            set_provide_text_document_content(
                uri: Uri<'function_context>,
                cancellation_token: bindgen_prelude::Object<'function_context>
            ) -> String;
            String = |returned_result: Option<String>| Ok(returned_result);
        }
    }
}
interface_builder! {
    TextEditor {}
}
field_getter! {
    TextEditor {
        "document": get_document -> TextDocument<'env>;
        "selections": get_selections -> Vec<Selection<'env>>;
    }
}
function_caller! {
    TextEditor {
        "setDecorations":
            set_decorations(
                decoration_type: TextEditorDecorationType,
                options: Vec<DecorationOptions>,
            ) -> ();
    }
}
interface_builder! {
    TextEditorDecorationType {}
}
interface_builder! {
    TextEditorSelectionChangeEvent {}
}
field_getter! {
    TextEditorSelectionChangeEvent {
        "textEditor": get_text_editor -> TextEditor<'env>;
        "selections": get_selections -> Vec<Selection<'env>>;
    }
}
interface_builder! {
    ThemableDecorationAttachmentRenderOptions {}
    ("color", color: &ThemeColor),
    ("contentText", content_text: &str),
    ("margin", margin: &str),
}
interface_builder! {
    UriWithChange {}
    ("scheme", scheme: &str),
    ("authority", authority: &str),
    ("path", path: &str),
    ("query", query: &str),
    ("fragment", fragment: &str),
}
interface_builder! {
    WorkspaceFolder {}
}
field_getter! {
    WorkspaceFolder {
        "uri": get_uri -> Uri<'env>;
    }
}
interface_builder! {
    WorkspaceFoldersChangeEvent {}
}
field_getter! {
    WorkspaceFoldersChangeEvent {
        "added": get_added -> Vec<WorkspaceFolder<'env>>;
        "removed": get_removed -> Vec<WorkspaceFolder<'env>>;
    }
}

macro_rules! register_provider {
    (
        $namespace:literal, $function_js_name:literal,
        $function_rust_name:ident(
            $($argument_name:ident: $argument_type:ty),+
        )
    ) => {
        // TODO: error handling
        pub fn $function_rust_name<'env>(
            env: &'env napi::Env,
            extension_context: &bindgen_prelude::Object,
            $($argument_name: $argument_type),+
        ) -> Result<(), napi::Error> {
            let vscode_object = super::VscodeContext::vscode(env)?;
            let namespace: bindgen_prelude::Object = vscode_object.get_named_property($namespace)?;
            let js_register_provider: bindgen_prelude::Function<
                bindgen_prelude::FnArgs<($($argument_type,)+)>,
                bindgen_prelude::Object,
            > = namespace.get_named_property($function_js_name)?;
            let subscription = js_register_provider
                .apply(namespace, bindgen_prelude::FnArgs::from(($($argument_name,)+)))?;
            let mut subscriptions: bindgen_prelude::Array =
                extension_context.get_named_property("subscriptions")?;
            subscriptions.insert(subscription)?;
            Ok(())
        }
    };
}
pub(crate) use register_provider;

macro_rules! object_reference {
    ($reference_name:ident: $owned_name:ident) => {
        pub struct $reference_name {
            inner: bindgen_prelude::ObjectRef,
        }
        impl $reference_name {
            pub fn get_inner<'env>(
                &self,
                env: &'env napi::Env,
            ) -> Result<$owned_name<'env>, napi::Error> {
                let inner = self.inner.get_value(env)?;
                Ok($owned_name { inner })
            }
        }
        impl<'env> $owned_name<'env> {
            pub fn create_ref(&self) -> Result<$reference_name, napi::Error> {
                let inner = self.inner.create_ref()?;
                Ok($reference_name { inner })
            }
        }
    };
}
pub(crate) use object_reference;

pub mod field;
pub mod function;

macro_rules! function_setter {
    ($interface_name:ident {
        $(
            $function_js_name:literal {
                $setter_name:ident(
                    $(
                        $function_argument_name:ident: $function_argument_type:ty
                    ),*
                ) -> $function_borrowed_return_type:ty;
                // TODO: remove this hack and properly handle types
                $function_owned_return_type:ty = $function_create_owned_return_type:expr;
            }
        )*
    }) => {
        impl<'env> $interface_name<'env> {
        $(
                pub fn $setter_name<F>(
                    &mut self,
                    env: &napi::Env,
                    function_callback: F,
                ) -> Result<(), napi::Error>
                where
                    F: for<'function_context> Fn(
                            &'function_context napi::Env,
                            $($function_argument_type,)*
                        ) -> Result<
                            Option<$function_borrowed_return_type>,
                            napi::Error,
                        > + 'static,
                {
                    let function_callback: bindgen_prelude::Function<
                        // Treat arguments as `Unknown` to make sure type errors are handled inside the closure
                        bindgen_prelude::Unknown,
                        // Extend the return type's lifetime beyond the lifetime of the closure
                        Option<$function_owned_return_type>,
                    > =
                        env.create_function_from_closure($function_js_name, move |function_context| {
                            // TODO: error handling
                            let ($($function_argument_name),*) = function_context.args()?;
                            let returned_result =
                                function_callback(function_context.env, $($function_argument_name),*)?;
                            $function_create_owned_return_type(returned_result)
                        })?;
                    self.inner.set_named_property($function_js_name, function_callback)?;
                    Ok(())
                }
            )*
        }
    };
}
pub(crate) use function_setter;

pub mod caller;
pub mod setter;

macro_rules! empty_function_caller {
    (
        $interface_name:ident {
            $(
                $empty_function_js_name:literal:
                    $empty_function_rust_name:ident() -> $empty_function_return_type:ty;
            )*
        }
    ) => {
        impl<'env> $interface_name<'env> {
            $(
                pub fn $empty_function_rust_name(
                    &self,
                ) -> Result<$empty_function_return_type, napi::Error> {
                    let js_function: bindgen_prelude::Function<
                        (),
                        $empty_function_return_type,
                    > = self.inner.get_named_property($empty_function_js_name)?;
                    js_function.apply(self.inner, ())
                }
            )*
        }
    };
}
macro_rules! function_caller {
    (
        $interface_name:ident {
            $(
                $function_js_name:literal:
                    $function_rust_name:ident(
                        $(
                            $function_argument_name:ident: $function_argument_type:ty,
                        )+
                    ) -> $function_return_type:ty;
            )*
        }
    ) => {
        impl<'env> $interface_name<'env> {
            $(
                pub fn $function_rust_name(
                    &self,
                    $($function_argument_name: $function_argument_type),+
                ) -> Result<$function_return_type, napi::Error> {
                    let js_function: bindgen_prelude::Function<
                        bindgen_prelude::FnArgs<($($function_argument_type,)+)>,
                        $function_return_type,
                    > = self.inner.get_named_property($function_js_name)?;
                    js_function.apply(self.inner, bindgen_prelude::FnArgs::from(($($function_argument_name,)+)))
                }
            )*
        }
    };
}
pub(crate) use empty_function_caller;
pub(crate) use function_caller;

macro_rules! field_setter {
    (
        $object_name:ident {
            $(
                $field_js_name:literal: $setter_name:ident($field_type:ty);
            )*
        }
    ) => {
        impl<'env> $object_name<'env> {
            $(
                pub fn $setter_name(&mut self, value: $field_type) -> Result<(), napi::Error> {
                    self.inner.set_named_property($field_js_name, value)
                }
            )*
        }
    };
}
pub(crate) use field_setter;

mod getter;
mod setter;
pub(crate) use getter::field_getter;
pub(crate) use setter::field_setter;

macro_rules! field_getter {
    (
        $object_name:ident {
            $(
                $field_js_name:literal: $getter_name:ident -> $field_type:ty;
            )*
        }
    ) => {
        impl<'env> $object_name<'env> {
            $(
                pub fn $getter_name(&self) -> Result<$field_type, napi::Error> {
                    self.inner.get_named_property($field_js_name)
                }
            )*
        }
    };
}
pub(crate) use field_getter;

pub mod field_getter;
pub mod function;

macro_rules! namespace_function {
    (
        $namespace:literal {
            $(
                $function_js_name:literal: $function_rust_name:ident(
                    $(
                        $argument_name:ident: $argument_type:ty,
                    )*
                ) -> $return_type:ty;
            )*
        }
    ) => {
        $(
            pub fn $function_rust_name<'env>(
                env: &napi::Env,
                $($argument_name: $argument_type),*
            ) -> Result<$return_type, napi::Error> {
                let vscode_object = super::VscodeContext::vscode(env)?;
                let namespace: bindgen_prelude::Object = vscode_object.get_named_property($namespace)?;
                let function_prototype: bindgen_prelude::Function<
                    bindgen_prelude::FnArgs<($($argument_type,)*)>,
                    $return_type,
                > = namespace.get_named_property($function_js_name)?;
                function_prototype.apply(
                    namespace,
                    bindgen_prelude::FnArgs::from(($($argument_name,)*)),
                )
            }
        )*
    };
}
pub(crate) use namespace_function;

macro_rules! namespace_field_getter {
    (
        $namespace:literal {
            $(
                $field_js_name:literal: $function_name:ident -> $field_type:ty;
            )*
        }
    ) => {
        $(
            pub fn $function_name<'env>(env: &'env napi::Env) -> Result<$field_type, napi::Error> {
                let vscode_object = super::VscodeContext::vscode(env)?;
                let window: bindgen_prelude::Object = vscode_object.get_named_property($namespace)?;
                window.get_named_property($field_js_name)
            }
        )*
    };
}
pub(crate) use namespace_field_getter;

mod class;
mod event_handler;
mod interface_builder;
mod namespace;
mod object;
mod object_reference;
mod register_provider;
pub(super) use class::static_method::static_class_method;
pub(super) use class::wrapper::class_wrapper;
pub(super) use event_handler::event_handler;
pub(super) use interface_builder::interface_builder;
pub(super) use namespace::field_getter::namespace_field_getter;
pub(super) use namespace::function::namespace_function;
pub(super) use object::field::field_getter;
pub(super) use object::field::field_setter;
pub(super) use object::function::caller::empty_function_caller;
pub(super) use object::function::caller::function_caller;
pub(super) use object::function::setter::function_setter;
pub(super) use object_reference::object_reference;
pub(super) use register_provider::register_provider;

macro_rules! interface_builder {
    (
        $interface_name:ident {
            $(
                (
                    $required_field_js_name:literal: $required_field_js_type:ty,
                    $required_field_rust_name:ident: $required_field_rust_type:ty
                ),
            )*
            $(
                $required_function_generic:ident: $required_function_setter:ident =
                    $required_function_rust_name:ident(
                        $(
                            $required_function_argument_name:ident: $required_function_argument_type:ty
                        ),*
                    ) -> $required_function_return_type:ty;
            )*
        }
        $(
            ($optional_field_js_name:literal, $optional_field_rust_name:ident: $optional_field_type:ty),
        )*
    ) => {
        #[derive(Clone, Copy)]
        pub struct $interface_name<'env> {
            inner: ::napi::bindgen_prelude::Object<'env>
        }
        impl<'env> $interface_name<'env> {
            pub fn new<$($required_function_generic),*>(
                env: &napi::Env,
                $($required_field_rust_name: $required_field_rust_type),*
                $($required_function_rust_name: $required_function_generic),*
            ) -> Result<Self, napi::Error>
            where
                $(
                    $required_function_generic: for<'function_context> Fn(
                        &'function_context napi::Env,
                        $($required_function_argument_type,)*
                    ) -> Result<
                        Option<$required_function_return_type>,
                        napi::Error,
                    > + 'static,
                )*
            {
                // TODO: generate more idiomatic code depending on if the object actually gets mutated
                #[allow(unused_mut)]
                let mut builder = Self {
                    inner: bindgen_prelude::Object::new(env)?,
                };
                // TODO: use Rust setters here
                $(builder.inner.set_named_property($required_field_js_name, $required_field_rust_name)?;)*
                $(builder.$required_function_setter(env, $required_function_rust_name)?;)*
                Ok(builder)
            }
            $(
                pub fn $optional_field_rust_name(mut self, $optional_field_rust_name: $optional_field_type) -> Result<Self, ::napi::Error> {
                    self.inner.set_named_property($optional_field_js_name, $optional_field_rust_name)?;
                    Ok(self)
                }
            )*
        }
        impl<'env> bindgen_prelude::ToNapiValue for &$interface_name<'env> {
            unsafe fn to_napi_value(env: napi_sys::napi_env, val: Self) -> Result<napi_sys::napi_value, napi::Error> {
                unsafe { bindgen_prelude::Object::to_napi_value(env, val.inner) }
            }
        }
        impl<'env> bindgen_prelude::ToNapiValue for $interface_name<'env> {
            unsafe fn to_napi_value(env: napi_sys::napi_env, val: Self) -> Result<napi_sys::napi_value, napi::Error> {
                unsafe { bindgen_prelude::Object::to_napi_value(env, val.inner) }
            }
        }
        impl<'env> bindgen_prelude::TypeName for $interface_name<'env> {
            fn type_name() -> &'static str {
                bindgen_prelude::Object::type_name()
            }
            fn value_type() -> napi::ValueType {
                bindgen_prelude::Object::value_type()
            }
        }
        // TODO: validate non-optional fields
        impl<'env> bindgen_prelude::FromNapiValue for $interface_name<'env> {
            unsafe fn from_napi_value(
                raw_env: napi_sys::napi_env,
                napi_val: napi_sys::napi_value,
            ) -> Result<Self, napi::Error> {
                let inner = unsafe { bindgen_prelude::Object::from_napi_value(raw_env, napi_val) }?;
                Ok(Self { inner })
            }
        }
        // TODO: validate functions
        impl<'env> bindgen_prelude::ValidateNapiValue for $interface_name<'env> {
            unsafe fn validate(
                raw_env: napi_sys::napi_env,
                raw_interface_value: napi_sys::napi_value,
            ) -> Result<napi_sys::napi_value, napi::Error> {
                // TODO: only generate when needed
                #[allow(unused)]
                let interface = match unsafe {
                    <bindgen_prelude::Object as bindgen_prelude::ValidateNapiValue>::validate(raw_env, raw_interface_value)
                } {
                    Ok(_validated_object) => bindgen_prelude::Object::from_raw(raw_env, raw_interface_value),
                    Err(error) => {
                        return Err(napi::Error::from_reason(format!(
                            "{} should be an Object: {}",
                            stringify!($interface_name),
                            error
                        )));
                    }
                };
                $(
                    let _property_value: $required_field_js_type = interface.get_named_property($required_field_js_name).map_err(|mut error| {
                        error.reason = format!(
                            "Error validating property {} of {}: {}",
                            $required_field_js_name,
                            stringify!($interface_name),
                            error.reason
                        );
                        error
                    })?;
                )*
                Ok(raw_interface_value)
            }
        }
    };
}
pub(crate) use interface_builder;

macro_rules! event_handler {
    (
        $namespace:literal, $function_js_name:literal, $function_rust_name:ident($event_type:ty)
    ) => {
        pub fn $function_rust_name<F>(
            env: &napi::Env,
            handler: F,
            // TODO: generic errors
        ) -> Result<(), napi::Error>
        where
            F: for<'function_context> Fn(
                    &'function_context napi::Env,
                    $event_type,
                ) -> Result<(), napi::Error>
                + 'static,
        {
            let extension_context = super::VscodeContext::extension_context(env)?;
            let mut subscriptions: bindgen_prelude::Array =
                extension_context.get_named_property("subscriptions")?;
            let vscode_object = super::VscodeContext::vscode(env)?;
            let namespace: bindgen_prelude::Object =
                vscode_object.get_named_property($namespace)?;
            let event_creator: bindgen_prelude::Function<
                bindgen_prelude::Function<$event_type, ()>,
                // TODO: disposable
                bindgen_prelude::Object,
            > = namespace.get_named_property($function_js_name)?;
            let event_handler_fn: bindgen_prelude::Function<$event_type, ()> = env
                .create_function_from_closure($function_js_name, move |function_context| {
                    let parent_span = tracing::span!(tracing::Level::TRACE, "event_handler");
                    let _entered_span = parent_span.enter();
                    let event = match function_context.args::<($event_type,)>() {
                        Ok((event,)) => event,
                        Err(error) => {
                            tracing::error!(
                                message = "Invalid arguments",
                                event_handler = $function_js_name,
                                ?error
                            );
                            return Ok(());
                        }
                    };
                    if let Err(error) = handler(function_context.env, event) {
                        tracing::error!(
                            message = "Handler exited unsuccessfully",
                            event_handler = $function_js_name,
                            ?error
                        );
                    }
                    Ok(())
                })?;
            let handler_subscription: bindgen_prelude::Object =
                event_creator.call(event_handler_fn)?;
            subscriptions.insert(handler_subscription)?;
            Ok(())
        }
    };
}
pub(crate) use event_handler;

// TODO: lifetimes when storing in e.g. statics
// TODO: either qualify everything or nothing
macro_rules! class_wrapper {
    ($class_name:ident($($argument_name:ident: $argument_type:ty),*)) => {
        pub struct $class_name<'env> {
            pub inner: ::napi::bindgen_prelude::Object<'env>,
        }
        impl<'env> $class_name<'env> {
            pub fn new(
                env: &napi::Env,
                $($argument_name: $argument_type),*
            ) -> Result<Self, ::napi::Error> {
                let vscode_object = VscodeContext::vscode(env)?;
                let constructor_prototype: ::napi::bindgen_prelude::Function<
                    'env,
                    ::napi::bindgen_prelude::FnArgs<($($argument_type,)*)>,
                    ::napi::bindgen_prelude::Object<'env>,
                > = vscode_object.get_named_property(stringify!($class_name))?;
                let class_result: ::napi::bindgen_prelude::Unknown =
                    constructor_prototype.new_instance(::napi::bindgen_prelude::FnArgs::from(($($argument_name,)*)))?;
                let class_object = ::napi::bindgen_prelude::Object::from_unknown(class_result)?;
                Ok(Self {
                    inner: class_object,
                })
            }
        }
        impl<'env> ToNapiValue for &$class_name<'env> {
            unsafe fn to_napi_value(env: napi_env, val: Self) -> Result<napi_value, napi::Error> {
                unsafe { bindgen_prelude::Object::to_napi_value(env, val.inner) }
            }
        }
        impl<'env> ToNapiValue for $class_name<'env> {
            unsafe fn to_napi_value(env: napi_env, val: Self) -> Result<napi_value, napi::Error> {
                unsafe { bindgen_prelude::Object::to_napi_value(env, val.inner) }
            }
        }
        // TODO: validate non-optional fields
        // TODO: move validation logic into validatenapivalue???
        impl<'env> FromNapiValue for $class_name<'env> {
            unsafe fn from_napi_value(
                raw_env: napi_sys::napi_env,
                napi_val: napi_sys::napi_value,
            ) -> Result<Self, napi::Error> {
                let inner = unsafe { bindgen_prelude::Object::from_napi_value(raw_env, napi_val) }?;
                Ok(Self { inner })
            }
        }
        impl<'env> TypeName for $class_name<'env> {
            fn type_name() -> &'static str {
                bindgen_prelude::Object::type_name()
            }
            fn value_type() -> napi::ValueType {
                bindgen_prelude::Object::value_type()
            }
        }
        impl<'env> ValidateNapiValue for $class_name<'env> {
            unsafe fn validate(
                raw_env: napi_sys::napi_env,
                raw_class: napi_sys::napi_value,
            ) -> Result<napi_sys::napi_value, napi::Error> {
                let class = match unsafe { <bindgen_prelude::Object as ValidateNapiValue>::validate(raw_env, raw_class) } {
                    Ok(_validated_class) => bindgen_prelude::Object::from_raw(raw_env, raw_class),
                    Err(mut error) => {
                        error.reason = format!("Invalid type for {}: {}", stringify!($class_name), error.reason);
                        return Err(error);
                    }
                };
                let env = napi::Env::from_raw(raw_env);
                let vscode_object = VscodeContext::vscode(&env)?;
                let constructor: bindgen_prelude::Function<bindgen_prelude::FnArgs<($($argument_type,)*)>, bindgen_prelude::Object> = vscode_object.get_named_property(stringify!($class_name))?;
                if !class.instanceof(constructor)? {
                    return Err(napi::Error::from_reason(
                        concat!("Object is not an instance of ", stringify!($class_name)),
                    ));
                }
                // TODO: validate fields
                Ok(raw_class)
            }
        }
    };
}
pub(crate) use class_wrapper;

macro_rules! static_class_method {
    (
        $class_name:ident {
            $(
                $function_js_name:literal:
                    $function_rust_name:ident(
                        $(
                            $function_argument_name:ident: $function_argument_type:ty,
                        )*
                    ) -> $function_return_type:ty;
            )*
        }
    ) => {
        impl<'env> $class_name<'env> {
            $(
                pub fn $function_rust_name(
                    env: &'env napi::Env,
                    $($function_argument_name: $function_argument_type),*
                ) -> Result<$function_return_type, napi::Error> {
                    let vscode_object = VscodeContext::vscode(env)?;
                    let constructor: ::napi::bindgen_prelude::Function<
                        bindgen_prelude::Unknown,
                        bindgen_prelude::Unknown,
                    > = vscode_object.get_named_property(stringify!($class_name))?;
                    let js_function: bindgen_prelude::Function<
                        bindgen_prelude::FnArgs<($($function_argument_type,)*)>,
                        $function_return_type,
                    > = constructor.get_named_property($function_js_name)?;
                    js_function.apply(constructor, bindgen_prelude::FnArgs::from(($($function_argument_name,)*)))
                }
            )*
        }
    };
}
pub(crate) use static_class_method;

pub mod static_method;
pub mod wrapper;

// TODO: https://github.com/tokio-rs/tracing/blob/main/examples/examples/panic_hook.rs
// TODO: Use a custom language ID in `window.createOutputChannel` to better format log messages
use napi::bindgen_prelude::{self, JsObjectValue};
use napi::threadsafe_function::ThreadsafeFunctionCallMode;
use tracing::{Level, Subscriber};
use tracing_subscriber::Layer;
use tracing_subscriber::fmt::{FormatFields, FormattedFields};
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::registry::LookupSpan;
struct VscodeLayer<F>
where
    F: for<'writer> FormatFields<'writer> + 'static,
{
    threadsafe_function: napi::threadsafe_function::ThreadsafeFunction<
        (&'static str, String),
        (),
        (&'static str, String),
        napi::Status,
        false,
        false,
        0,
    >,
    field_formatter: F,
}
impl<F> VscodeLayer<F>
where
    F: for<'writer> FormatFields<'writer> + 'static,
{
    fn new(env: &napi::Env, name: &str, field_formatter: F) -> Result<Self, napi::Error> {
        let output_channel = super::window::create_log_output_channel(env, name)?;
        let threadsafe_function: bindgen_prelude::Function<(&str, String), ()> = env
            .create_function_from_closure("tracing_event_handler", |function_context| {
                let ((method, message),): ((String, String),) = function_context.args()?;
                let output_channel: bindgen_prelude::Object = function_context.this()?;
                let log_function: bindgen_prelude::Function<String, ()> =
                    output_channel.get_named_property(&method)?;
                log_function.apply(output_channel, message)
            })?;
        // TODO: build_callback so can pass rust values
        let threadsafe_function = threadsafe_function
            .bind(output_channel)?
            .build_threadsafe_function()
            .callee_handled::<false>()
            .max_queue_size::<0>()
            .weak::<false>()
            .build()?;
        Ok(Self {
            threadsafe_function,
            field_formatter,
        })
    }
    fn call_output_channel<S: Into<String>>(&self, level: Level, message: S) {
        let level = match level {
            Level::TRACE => "trace",
            Level::DEBUG => "debug",
            Level::INFO => "info",
            Level::WARN => "warn",
            Level::ERROR => "error",
        };
        let status = self.threadsafe_function.call(
            // Ok((level, message.into())),
            (level, message.into()),
            ThreadsafeFunctionCallMode::Blocking,
        );
    }
    fn internal_message<S: core::fmt::Display>(&self, level: Level, message: S) {
        self.call_output_channel(level, format!("Internal tracing message: {message}"));
    }
}
impl<F, S> Layer<S> for VscodeLayer<F>
where
    F: for<'writer> FormatFields<'writer> + 'static,
    S: Subscriber + for<'registry> LookupSpan<'registry>,
{
    fn on_new_span(
        &self,
        attributes: &tracing::span::Attributes<'_>,
        id: &tracing::span::Id,
        context: tracing_subscriber::layer::Context<'_, S>,
    ) {
        let Some(span) = context.span(id) else {
            self.internal_message(Level::ERROR, format!("no matching span for ID: {id:#?}"));
            return;
        };
        let mut extensions = span.extensions_mut();
        if extensions.get_mut::<FormattedFields<F>>().is_none() {
            let mut formatted_fields: FormattedFields<F> = FormattedFields::new(String::new());
            let format_result = self
                .field_formatter
                .format_fields(formatted_fields.as_writer(), attributes);
            match format_result {
                Ok(()) => extensions.insert(formatted_fields),
                Err(error) => {
                    self.internal_message(Level::ERROR, format!("failed to format fields: {error}"))
                }
            }
        }
    }
    fn on_event(
        &self,
        event: &tracing::Event<'_>,
        context: tracing_subscriber::layer::Context<'_, S>,
    ) {
        let mut message = String::new();
        if let Some(event_scope) = context.event_scope(event) {
            for span in event_scope.from_root() {
                message.push_str(span.name());
                match span.extensions().get::<FormattedFields<F>>() {
                    Some(formatted_fields) => {
                        if !formatted_fields.is_empty() {
                            message.push('{');
                            message.push_str(formatted_fields);
                            message.push('}');
                        }
                    }
                    None => {
                        self.internal_message(
                            Level::WARN,
                            format!("no formatted fields stored for {:#?}", span.id()),
                        );
                        message.push_str("{missing fields}");
                    }
                }
                message.push(':');
            }
        }
        match event.metadata().module_path() {
            Some(module_path) => {
                if !message.is_empty() {
                    message.push(' ');
                }
                message.push_str(module_path);
                message.push_str(": ");
            }
            None => {
                self.internal_message(
                    Level::WARN,
                    format!(
                        "missing module path for event at callsite {:#?}",
                        event.metadata().callsite()
                    ),
                );
            }
        }
        // TODO: https://github.com/tokio-rs/tracing/issues/3335
        let writer = tracing_subscriber::fmt::format::Writer::new(&mut message);
        if let Err(error) = self.field_formatter.format_fields(writer, event) {
            self.internal_message(
                Level::ERROR,
                format!("failed to write event fields: {error}"),
            );
        }
        self.call_output_channel(*event.metadata().level(), message);
    }
}
pub fn init<F>(env: &napi::Env, name: &str, field_formatter: F) -> Result<(), napi::Error>
where
    F: for<'writer> FormatFields<'writer> + Send + Sync + 'static,
{
    let vscode_layer = VscodeLayer::new(env, name, field_formatter)?;
    // TODO: https://docs.rs/tracing-appender/latest/tracing_appender/
    let subscriber = tracing_subscriber::registry().with(vscode_layer);
    tracing::subscriber::set_global_default(subscriber).map_err(|error| {
        napi::Error::from_reason(format!("Failed to set global default subscriber: {error}"))
    })?;
    Ok(())
}

use std::collections::HashMap;
use camino::{Utf8Path, Utf8PathBuf};
use pijul_extension::FileSystemRepository;
use crate::vscode_sys::reference::{
    SourceControlRef, SourceControlResourceGroupRef, TextEditorRef,
};
use crate::vscode_sys::{self, SourceControlResourceState};
use crate::vscode_sys::{TextEditor, Uri};
// TODO: remove public fields
pub struct OpenRepository {
    pub repository: FileSystemRepository,
    pub source_control: SourceControlRef,
    open_editors: HashMap<Utf8PathBuf, TextEditorRef>,
    unrecorded_changes: SourceControlResourceGroupRef,
    untracked_paths: SourceControlResourceGroupRef,
}
impl OpenRepository {
    #[tracing::instrument(skip_all)]
    pub fn new(
        env: &napi::Env,
        // TODO: pass SourceControl directly instead of URI?
        repository_uri: &Uri,
        // open_editors: HashMap<Utf8PathBuf, TextEditor>,
        // TODO: thiserror
    ) -> Result<Self, napi::Error> {
        tracing::debug!(message = "Opening repository", uri = ?repository_uri.to_string()?);
        let repository_path = Utf8PathBuf::from(repository_uri.get_fs_path()?);
        let source_control =
            vscode_sys::scm::create_source_control(env, "pijul", "Pijul", repository_uri)?;
        let repository = FileSystemRepository::new(&repository_path).map_err(|error| {
            napi::Error::from_reason(format!(
                "cannot open workspace at {repository_path}: {error}"
            ))
        })?;
        tracing::debug!("repository");
        let mut unrecorded_changes = source_control.create_resource_group("changes", "Changes")?;
        let mut untracked_paths = source_control.create_resource_group("untracked", "Untracked")?;
        tracing::debug!("resource groups");
        let mut modified_resource_states = Vec::new();
        tracing::debug!("starting loop");
        for relative_modified_path in repository.iter_modified() {
            let absolute_modified_path = repository_path.join(relative_modified_path);
            let resource_uri = Uri::file(env, absolute_modified_path.as_str())?;
            let resource_state = SourceControlResourceState::new(env, &resource_uri)?;
            modified_resource_states.push(resource_state)
        }
        unrecorded_changes.set_resource_states(modified_resource_states)?;
        let mut untracked_resource_states = Vec::new();
        for relative_untracked_path in repository.iter_untracked() {
            let absolute_untracked_path = repository_path.join(relative_untracked_path);
            tracing::debug!(path = absolute_untracked_path.as_str());
            let resource_uri = Uri::file(env, absolute_untracked_path.as_str())?;
            let resource_state = SourceControlResourceState::new(env, &resource_uri)?;
            untracked_resource_states.push(resource_state)
        }
        untracked_paths.set_resource_states(untracked_resource_states)?;
        tracing::debug!("resource states");
        Ok(Self {
            source_control: source_control.create_ref()?,
            repository,
            unrecorded_changes: unrecorded_changes.create_ref()?,
            untracked_paths: untracked_paths.create_ref()?,
            open_editors: HashMap::new(),
        })
    }
    #[tracing::instrument(skip_all)]
    pub fn register_text_editor(
        &mut self,
        path: Utf8PathBuf,
        text_editor: TextEditor,
    ) -> Result<(), napi::Error> {
        if self.repository.get_open_file(&path).is_none() {
            let document = text_editor.get_document()?;
            let file_contents = document.get_text(None)?;
            // TODO: proper error handling
            self.repository
                .create_open_file(path.clone(), file_contents)
                .map_err(|error| {
                    napi::Error::from_reason(format!("Unable to create open file: {error}"))
                })?;
            let text_editor_reference = text_editor.create_ref()?;
            self.open_editors
                .try_insert(path, text_editor_reference)
                .map_err(|_error| napi::Error::from_reason("Text editor already exists"))?;
        }
        Ok(())
    }
    #[tracing::instrument(skip_all)]
    pub fn get_text_editor<'env>(
        &self,
        env: &'env napi::Env,
        path: &Utf8Path,
    ) -> Result<Option<TextEditor<'env>>, napi::Error> {
        self.open_editors
            .get(path)
            .map(|reference| reference.get_inner(env))
            .transpose()
    }
}

use std::collections::HashMap;
use camino::Utf8PathBuf;
use crate::repository::open_repository::OpenRepository;
use crate::vscode_sys;
mod open_repository;
#[derive(Default)]
pub struct OpenRepositories {
    // TODO: proper URIs
    // TODO: multiple repositories per workspace folder
    repositories: HashMap<Utf8PathBuf, OpenRepository>,
}
impl OpenRepositories {
    #[tracing::instrument(skip_all)]
    pub fn new() -> Self {
        Self::default()
    }
    #[tracing::instrument(skip_all)]
    pub fn get_open_repository(
        &self,
        env: &napi::Env,
        uri: &vscode_sys::Uri,
    ) -> Result<Option<(Utf8PathBuf, &OpenRepository)>, napi::Error> {
        let Some(workspace_folder) = vscode_sys::workspace::get_workspace_folder(env, uri)? else {
            tracing::debug!(
                message = "URI does not correspond to a workspace folder",
                uri = ?uri.to_string()
            );
            return Ok(None);
        };
        let workspace_uri = workspace_folder.get_uri()?;
        let workspace_path = Utf8PathBuf::from(workspace_uri.get_fs_path()?);
        Ok(self
            .repositories
            .get(&workspace_path)
            .map(|open_repository| (workspace_path, open_repository)))
    }
    #[tracing::instrument(skip_all)]
    pub fn get_open_repository_mut(
        &mut self,
        env: &napi::Env,
        uri: &vscode_sys::Uri,
    ) -> Result<Option<(Utf8PathBuf, &mut OpenRepository)>, napi::Error> {
        let Some(workspace_folder) = vscode_sys::workspace::get_workspace_folder(env, uri)? else {
            tracing::debug!(
                message = "URI does not correspond to a workspace folder",
                uri = ?uri.to_string()
            );
            return Ok(None);
        };
        let workspace_uri = workspace_folder.get_uri()?;
        let workspace_path = Utf8PathBuf::from(workspace_uri.get_fs_path()?);
        Ok(self
            .repositories
            .get_mut(&workspace_path)
            .map(|open_repository| (workspace_path, open_repository)))
    }
    pub fn register_text_editors(
        &mut self,
        env: &napi::Env,
        text_editors: Vec<vscode_sys::TextEditor>,
    ) -> Result<(), napi::Error> {
        for text_editor in text_editors {
            let document = text_editor.get_document()?;
            let uri = document.get_uri()?;
            if let Some((repository_path, open_repository)) =
                self.get_open_repository_mut(env, &uri)?
            {
                let absolute_editor_path = Utf8PathBuf::from(uri.get_fs_path()?);
                let relative_editor_path = absolute_editor_path
                    .strip_prefix(&repository_path)
                    // TODO: error handling
                    .unwrap()
                    .to_path_buf();
                open_repository.register_text_editor(relative_editor_path, text_editor)?;
                tracing::debug!(
                    message = "Registered text editor",
                    ?repository_path,
                    uri = uri.to_string()?
                );
            } else {
                // Ignore documents not part of any workspace folder
                tracing::debug!(
                    message = "Ignoring text editor without valid workspace",
                    uri = uri.to_string()?
                );
            }
        }
        Ok(())
    }
    #[tracing::instrument(skip_all)]
    pub fn open_workspace_folder(
        &mut self,
        env: &napi::Env,
        workspace_folder: vscode_sys::WorkspaceFolder,
    ) -> Result<(), napi::Error> {
        let repository_uri = workspace_folder.get_uri()?;
        let repository_path = Utf8PathBuf::from(repository_uri.get_fs_path()?);
        let open_repository = OpenRepository::new(env, &repository_uri)?;
        if self
            .repositories
            .try_insert(repository_path.clone(), open_repository)
            .is_err()
        {
            tracing::error!(
                message = "Failed to insert duplicate repository",
                ?repository_path
            );
        }
        Ok(())
    }
    #[tracing::instrument(skip_all)]
    pub fn close_workspace_folder(
        &mut self,
        workspace_folder: vscode_sys::WorkspaceFolder,
    ) -> Result<(), napi::Error> {
        let repository_uri = workspace_folder.get_uri()?;
        let repository_path = Utf8PathBuf::from(repository_uri.get_fs_path()?);
        if self.repositories.remove(&repository_path).is_none() {
            tracing::error!(
                message = "Failed to remove repository that does not exist",
                ?repository_path
            );
        }
        Ok(())
    }
    // TODO: remove this
    #[tracing::instrument(skip_all)]
    pub fn iter_repositories(&self) -> impl Iterator<Item = (&Utf8PathBuf, &OpenRepository)> {
        self.repositories.iter()
    }
}

#![feature(map_try_insert)]
#![feature(mapped_lock_guards)]
// TODO: panic handler
// TODO: fix credits in quick diff panel
// TODO: quick diff untracked files
// TODO: find a way to validate all subscriptions are disposed? or just standardize how they are registered
// TODO: replace `get_repository_folder` with something that can handle nested repositories
// TODO: consistent naming
// TODO: handle adding/removing workspace folders (and adding/removing .pijul folders)
// TODO: handle changing active text editors
// TODO: color workspace root with `gitDecoration.submoduleResourceForeground`?
// TODO: something breaks when opening quick diff
// TODO: static handling of package.json contributions
// TODO: move l10n into pijul-extension
use std::sync::{Mutex, MutexGuard, OnceLock};
use camino::Utf8PathBuf;
use napi::bindgen_prelude;
use napi_derive::napi;
use pijul_extension::{PathState, TrackedState};
use repository::OpenRepositories;
mod decorations;
mod repository;
mod vscode_sys;
static EXTENSION_STATE: OnceLock<Mutex<ExtensionState>> = OnceLock::new();
pub const PIJUL_SCHEME: &str = "pijul";
struct ExtensionState {
    decoration_type: vscode_sys::reference::TextEditorDecorationTypeRef,
    repositories: OpenRepositories,
}
impl ExtensionState {
    fn get() -> Result<MutexGuard<'static, Self>, napi::Error> {
        EXTENSION_STATE
            .get()
            .ok_or_else(|| napi::Error::from_reason("Extension state is not set"))?
            .lock()
            .map_err(|_error| napi::Error::from_reason("Extension state mutex has been poisoned"))
    }
}
fn provide_file_decoration<'env>(
    env: &'env napi::Env,
    uri: vscode_sys::Uri,
    _cancellation_token: bindgen_prelude::Object,
) -> Result<Option<vscode_sys::FileDecoration<'env>>, napi::Error> {
    let program_state = ExtensionState::get()?;
    let Some((repository_path, open_repository)) =
        program_state.repositories.get_open_repository(env, &uri)?
    else {
        return Ok(None);
    };
    let absolute_file_path = Utf8PathBuf::from(uri.get_fs_path()?);
    let relative_file_path =
        absolute_file_path
            .strip_prefix(&repository_path)
            .map_err(|error| {
                napi::Error::from_reason(format!(
                    "Failed to strip prefix {repository_path} from {absolute_file_path}: {error}"
                ))
            })?;
    let Some(path_state) = open_repository
        .repository
        .get_path_state(relative_file_path)
    else {
        return Ok(None);
    };
    // TODO: l10n_embed
    let (badge, tooltip, color_id) = match path_state {
        PathState::Untracked => ("U", "Untracked", "pijul.decorations.path.untracked"),
        PathState::Tracked(modified_state) => match modified_state {
            TrackedState::Added => ("A", "Added", "pijul.decorations.path.added"),
            TrackedState::Removed => ("RM", "Removed", "pijul.decorations.path.removed"),
            TrackedState::Modified => ("M", "Modified", "pijul.decorations.path.modified"),
            TrackedState::Moved => ("MV", "Moved", "pijul.decorations.path.moved"),
            TrackedState::ModifiedAndMoved => (
                "M,MV",
                "Modified, Moved",
                "pijul.decorations.path.modifiedAndMoved",
            ),
        },
    };
    let color = vscode_sys::ThemeColor::new(env, color_id)?;
    let path_decoration = vscode_sys::FileDecoration::new(env, badge, tooltip, &color)?;
    Ok(Some(path_decoration))
}
fn provide_text_document_content(
    env: &napi::Env,
    pijul_uri: vscode_sys::Uri,
    _cancellation_token: bindgen_prelude::Object,
) -> Result<Option<String>, napi::Error> {
    let program_state = ExtensionState::get()?;
    let uri_change = vscode_sys::UriWithChange::new(env)?.scheme("file")?;
    let uri = pijul_uri.with(uri_change)?;
    if let Some((workspace_path, workspace)) =
        program_state.repositories.get_open_repository(env, &uri)?
    {
        let absolute_path = Utf8PathBuf::from(uri.get_fs_path()?);
        let relative_path = absolute_path
            .strip_prefix(&workspace_path)
            .map_err(|error| {
                napi::Error::from_reason(format!(
                    "Failed to strip prefix {workspace_path} from {absolute_path}: {error}"
                ))
            })?;
        match workspace.repository.get_open_file(relative_path) {
            Some(open_file) => Ok(Some(open_file.tracked_contents())),
            None => {
                tracing::error!(
                    message = "No tracked file state for {relative_path}",
                    ?workspace_path
                );
                Ok(None)
            }
        }
    } else {
        tracing::debug!(message = "Ignoring URI", uri = uri.to_string()?);
        Ok(None)
    }
}
fn provide_original_resource<'env>(
    env: &'env napi::Env,
    uri: vscode_sys::Uri<'env>,
    _cancellation_token: bindgen_prelude::Object,
) -> Result<Option<vscode_sys::Uri<'env>>, napi::Error> {
    // TODO: create a proper uri that preserves everything, including the original scheme
    let uri_change = vscode_sys::UriWithChange::new(env)?.scheme(PIJUL_SCHEME)?;
    let pijul_uri = uri.with(uri_change)?;
    Ok(Some(pijul_uri))
}
#[tracing::instrument(skip_all)]
fn on_did_change_text_document(
    env: &napi::Env,
    event: vscode_sys::TextDocumentChangeEvent,
) -> Result<(), napi::Error> {
    let mut program_state = ExtensionState::get()?;
    let text_document = event.get_document()?;
    let document_uri = text_document.get_uri()?;
    // Ignore any messages printed to the `Output` channel (used by `tracing`)
    if document_uri.get_scheme()? == "output" {
        return Ok(());
    }
    if let Some((repository_path, open_repository)) = program_state
        .repositories
        .get_open_repository_mut(env, &document_uri)?
    {
        let absolute_document_path = Utf8PathBuf::from(document_uri.get_fs_path()?);
        tracing::debug!(?absolute_document_path);
        let relative_document_path = absolute_document_path
            .strip_prefix(&repository_path)
            .map_err(|error| napi::Error::from_reason(format!("Failed to strip prefix {repository_path} from {absolute_document_path}: {error}")))?;
        let change_events = event.get_content_changes()?;
        for change_event in change_events {
            let character_offset = change_event.get_range_offset()?;
            let characters_replaced = change_event.get_range_length()?;
            let replacement_text = change_event.get_text()?;
            open_repository
                .repository
                .update_open_file(
                    relative_document_path,
                    character_offset as usize,
                    characters_replaced as usize,
                    &replacement_text,
                )
                .map_err(|error| {
                    napi::Error::from_reason(format!(
                        "Unable to update open file {relative_document_path} ({absolute_document_path}): {error}"
                    ))
                })?;
        }
        // TODO: avoid the flashing this causes
        // Re-render the inline credit annotation
        let text_editor = open_repository
            .get_text_editor(env, relative_document_path)?
            .ok_or_else(|| {
                napi::Error::from_reason(format!(
                    "no open text editor for {absolute_document_path}"
                ))
            })?;
        let selections = text_editor.get_selections()?;
        decorations::inline_credit::render(env, &program_state, &text_editor, selections)?;
    }
    Ok(())
}
#[tracing::instrument(skip_all)]
fn on_did_change_text_editor_selections(
    env: &napi::Env,
    event: vscode_sys::TextEditorSelectionChangeEvent,
) -> Result<(), napi::Error> {
    let program_state = ExtensionState::get()?;
    let editor = event.get_text_editor()?;
    let document = editor.get_document()?;
    let uri = document.get_uri()?;
    // Ignore any messages printed to the `Output` channel (used by `tracing`)
    if uri.get_scheme()? == "output" {
        return Ok(());
    }
    let selections = event.get_selections()?;
    decorations::inline_credit::render(env, &program_state, &editor, selections)
}
#[tracing::instrument(skip_all)]
fn on_did_change_workspace_folders(
    env: &napi::Env,
    event: vscode_sys::WorkspaceFoldersChangeEvent,
) -> Result<(), napi::Error> {
    let mut program_state = ExtensionState::get()?;
    let added_workspaces = event.get_added()?;
    let removed_workspaces = event.get_removed()?;
    for added_workspace in added_workspaces {
        program_state
            .repositories
            .open_workspace_folder(env, added_workspace)?;
    }
    for removed_workspace in removed_workspaces {
        program_state
            .repositories
            .close_workspace_folder(removed_workspace)?;
    }
    Ok(())
}
// TODO: handle closing text editors
#[tracing::instrument(skip_all)]
fn on_did_change_visible_text_editors(
    env: &napi::Env,
    visible_text_editors: Vec<vscode_sys::TextEditor>,
) -> Result<(), napi::Error> {
    let mut extension_state = ExtensionState::get()?;
    extension_state
        .repositories
        .register_text_editors(env, visible_text_editors)
}
// TODO: make sure things are registered in order:
// 1. Create extension state
// 2. First-time init e.g. initial inline credit and open files
// 3. Register extension state
// 4. Providers
// 5. Event handlers
// TODO: remove catch_unwind (make activate_internal)
#[napi(catch_unwind)]
pub fn activate(
    env: &napi::Env,
    vscode_object: bindgen_prelude::Object,
    extension_context: bindgen_prelude::Object,
) -> Result<(), napi::Error> {
    vscode_sys::activate(&vscode_object, &extension_context)?;
    vscode_sys::log::init(
        env,
        "Pijul",
        tracing_subscriber::fmt::format::DefaultFields::new(),
    )?;
    let mut repositories = OpenRepositories::new();
    for workspace_folder in vscode_sys::workspace::get_workspace_folders(env)? {
        repositories.open_workspace_folder(env, workspace_folder)?;
    }
    let visible_text_editors = vscode_sys::window::get_visible_text_editors(env)?;
    repositories.register_text_editors(env, visible_text_editors)?;
    let decoration_type = decorations::create_decoration_type(env)?;
    let extension_state = ExtensionState {
        decoration_type: decoration_type.create_ref()?,
        repositories,
    };
    if let Some(active_text_editor) = vscode_sys::window::get_active_text_editor(env)? {
        let selections = active_text_editor.get_selections()?;
        decorations::inline_credit::render(env, &extension_state, &active_text_editor, selections)?;
    }
    EXTENSION_STATE
        .set(Mutex::new(extension_state))
        .map_err(|_existing_object| {
            napi::Error::from_reason("Extension state has already been set")
        })?;
    let file_decoration_provider =
        vscode_sys::FileDecorationProvider::new(env, provide_file_decoration)?;
    vscode_sys::window::register_file_decoration_provider(
        env,
        &extension_context,
        file_decoration_provider,
    )?;
    let text_document_provider =
        vscode_sys::TextDocumentContentProvider::new(env, provide_text_document_content)?;
    vscode_sys::workspace::register_text_document_content_provider(
        env,
        &extension_context,
        PIJUL_SCHEME,
        text_document_provider,
    )?;
    let mut quick_diff_provider = vscode_sys::QuickDiffProvider::new(env)?;
    quick_diff_provider.set_provide_original_resource(env, provide_original_resource)?;
    let program_state = ExtensionState::get()?;
    for (_repository_path, open_repository) in program_state.repositories.iter_repositories() {
        let mut source_control = open_repository.source_control.get_inner(env)?;
        source_control.set_quick_diff_provider(quick_diff_provider)?;
    }
    vscode_sys::window::on_did_change_text_editor_selections(
        env,
        on_did_change_text_editor_selections,
    )?;
    vscode_sys::window::on_did_change_visible_text_editors(
        env,
        on_did_change_visible_text_editors,
    )?;
    vscode_sys::workspace::on_did_change_text_document(env, on_did_change_text_document)?;
    vscode_sys::workspace::on_did_change_workspace_folders(env, on_did_change_workspace_folders)?;
    tracing::info!("Extension activated");
    Ok(())
}

// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from "vscode";
import nativeModule from "../out/native-module";
// This method is called when your extension is activated
// Your extension is activated the very first time the command is executed
export function activate(context: vscode.ExtensionContext) {
	// Use the console to output diagnostic information (console.log) and errors (console.error)
	// This line of code will only be executed once when your extension is activated
	console.log('Congratulations, your extension "pijul-vscode" is now active!');
	nativeModule.activate(vscode, context);
	// The command has been defined in the package.json file
	// Now provide the implementation of the command with registerCommand
	// The commandId parameter must match the command field in package.json
	const disposable = vscode.commands.registerCommand(
		"pijul-vscode.helloWorld",
		() => {
			// The code you place here will be executed every time your command is executed
			// Display a message box to the user
			vscode.window.showInformationMessage("Hello World from pijul-vscode!");
		},
	);
	context.subscriptions.push(disposable);
}
// This method is called when your extension is deactivated
export function deactivate() {}

use crate::vscode_sys;
pub mod inline_credit;
pub fn create_decoration_type<'env>(
    env: &'env napi::Env,
) -> Result<vscode_sys::TextEditorDecorationType<'env>, napi::Error> {
    let theme_color =
        vscode_sys::ThemeColor::new(env, "pijul.decorations.inlineCredit.foreground")?;
    let after = vscode_sys::ThemableDecorationAttachmentRenderOptions::new(env)?
        // Margin of roughly 10 characters to the right
        // https://developer.mozilla.org/en-US/docs/Web/CSS/length#ch
        .margin("0 0 0 10ch")?
        .color(&theme_color)?;
    let render_options = vscode_sys::DecorationRenderOptions::new(env)?.after(after)?;
    let decoration_type =
        vscode_sys::window::create_text_editor_decoration_type(env, render_options)?;
    Ok(decoration_type)
}

// TODO: better, localized hover messages
// TODO: generate the enums in their own impl blocks
use std::ops::RangeInclusive;
use camino::Utf8PathBuf;
use icu_locale::locale;
use jiff::Timestamp;
use l10n_embed::Localize;
use l10n_embed_derive::localize;
use napi::bindgen_prelude::JsObjectValue;
use pijul_extension::FileSystemRepository;
use pijul_extension::file_system::changes::CreditSource;
use pijul_extension::file_system::changes::Span;
use pijul_extension::file_system::open_file::OpenFile;
use crate::ExtensionState;
use crate::vscode_sys;
#[localize("l10n/**/inline_credit.ftl")]
enum AuthorKind<'change_header> {
    Local,
    Remote {
        username: &'change_header str,
    },
    Unknown {
        public_key_signature: &'change_header str,
    },
}
#[localize("l10n/**/inline_credit.ftl")]
enum InlineCreditAnnotation<'change_header> {
    Tracked {
        authors: l10n_embed::list::AndList<AuthorKind<'change_header>>,
        timestamp: Timestamp,
        message: &'change_header str,
    },
    Untracked {
        timestamp: Timestamp,
    },
}
fn get_lines_selected(
    editor_selections: Vec<vscode_sys::Selection>,
) -> Result<Vec<RangeInclusive<usize>>, napi::Error> {
    let mut credits = Vec::with_capacity(editor_selections.len());
    for editor_selection in &editor_selections {
        let start_line = editor_selection.get_start()?.get_line()?;
        let end_line: u32 = editor_selection.get_end()?.get_line()?;
        credits.push((start_line as usize)..=(end_line as usize));
    }
    Ok(credits)
}
fn decoration_options<'env>(
    env: &napi::Env,
    localization_context: &l10n_embed::Context,
    repository: &FileSystemRepository,
    open_file: &OpenFile,
    credits: impl Iterator<Item = Span<CreditSource>>,
) -> Result<Vec<vscode_sys::DecorationOptions<'env>>, napi::Error> {
    let mut decoration_options_list = Vec::new();
    for credit in credits {
        tracing::debug!(?credit);
        let annotation = match credit.value {
            CreditSource::Tracked(change_id) => {
                let change_header = repository.get_change_header(&change_id).ok_or_else(|| {
                    napi::Error::from_reason(format!("unable to get change {change_id:#?}"))
                })?;
                let authors = repository
                    .authors_for_change(change_header)
                    .into_iter()
                    .map(|author_source| match author_source {
                        pijul_extension::author::AuthorSource::Local(_identity) => {
                            AuthorKind::Local
                        }
                        pijul_extension::author::AuthorSource::Remote(identity) => {
                            AuthorKind::Remote {
                                username: &identity.config.author.username,
                            }
                        }
                        pijul_extension::author::AuthorSource::Unknown(public_key_signature) => {
                            AuthorKind::Unknown {
                                public_key_signature,
                            }
                        }
                    })
                    .collect();
                InlineCreditAnnotation::Tracked {
                    authors: l10n_embed::list::AndList::new(authors),
                    timestamp: change_header.timestamp,
                    message: &change_header.message,
                }
            }
            CreditSource::Untracked => InlineCreditAnnotation::Untracked {
                timestamp: Timestamp::try_from(open_file.contents.modified_time).map_err(
                    |error| {
                        napi::Error::from_reason(format!(
                            "Failed to parse timestamp {:#?}: {error}",
                            open_file.contents.modified_time
                        ))
                    },
                )?,
            },
        };
        let mut localized_annotation = String::new();
        annotation.localize(localization_context, &mut localized_annotation);
        let hover_message_text = match credit.value {
            CreditSource::Tracked(change_id) => {
                let change_header = repository.get_change_header(&change_id).ok_or_else(|| {
                    napi::Error::from_reason(format!("unable to get change {change_id:#?}"))
                })?;
                match &change_header.description {
                    Some(description) => {
                        format!("<h2>{}</h2><p>{}</p>", change_header.message, description)
                    }
                    None => change_header.message.clone(),
                }
            }
            CreditSource::Untracked => String::new(),
        };
        for line in credit.lines {
            let current_line_contents = open_file
                .contents
                .text
                .get_line(line, ropey::LineType::LF_CR)
                .ok_or_else(|| napi::Error::from_reason(format!("no contents for line {line}")))?;
            let final_character_offset = current_line_contents.len() as u32;
            let start = vscode_sys::Position::new(env, line as u32, final_character_offset)?;
            let end = vscode_sys::Position::new(env, line as u32, final_character_offset)?;
            let range = vscode_sys::Range::new(env, &start, &end)?;
            let mut hover_message =
                vscode_sys::MarkdownString::new(env, &hover_message_text, false)?;
            hover_message
                .inner
                .set_named_property("supportHtml", true)?;
            let after = vscode_sys::ThemableDecorationAttachmentRenderOptions::new(env)?
                .content_text(&localized_annotation)?;
            let render_options =
                vscode_sys::DecorationInstanceRenderOptions::new(env)?.after(after)?;
            let decoration_options = vscode_sys::DecorationOptions::new(env, &range)?
                .hover_message(&hover_message)?
                .render_options(render_options)?;
            decoration_options_list.push(decoration_options);
        }
    }
    Ok(decoration_options_list)
}
// TODO: different rendering modes? e.g. render only at boundaries between lines, render only on cursors, etc
pub fn render(
    env: &napi::Env,
    program_state: &ExtensionState,
    editor: &vscode_sys::TextEditor,
    selections: Vec<vscode_sys::Selection>,
) -> Result<(), napi::Error> {
    let editor_document = editor.get_document()?;
    let document_uri = editor_document.get_uri()?;
    let Some((repository_path, open_repository)) = program_state
        .repositories
        .get_open_repository(env, &document_uri)?
    else {
        return Ok(());
    };
    let absolute_file_path = Utf8PathBuf::from(document_uri.get_fs_path()?);
    let relative_file_path =
        absolute_file_path
            .strip_prefix(&repository_path)
            .map_err(|error| {
                napi::Error::from_reason(format!(
                    "Failed to strip prefix {repository_path} from {absolute_file_path}: {error}"
                ))
            })?;
    let localization_context = l10n_embed::Context::new(locale!("en-US"), false);
    let lines_selected = get_lines_selected(selections)?;
    let open_file = open_repository
        .repository
        .get_open_file(relative_file_path)
        .ok_or_else(|| {
            napi::Error::from_reason(format!("unable to get open file for {relative_file_path}"))
        })?;
    let credits = lines_selected
        .into_iter()
        .flat_map(|line_range| open_file.credit(line_range));
    let decoration_options = decoration_options(
        env,
        &localization_context,
        &open_repository.repository,
        open_file,
        credits,
    )?;
    let decoration_type = program_state.decoration_type.get_inner(env)?;
    editor.set_decorations(decoration_type, decoration_options)?;
    Ok(())
}

lockfileVersion: '9.0'
settings:
  autoInstallPeers: true
  excludeLinksFromLockfile: false
importers:
  .:
    devDependencies:
      '@napi-rs/cli':
        specifier: ^3.3.1
        version: 3.4.1(@emnapi/runtime@1.7.1)(@types/node@22.19.1)
      '@types/node':
        specifier: 22.x
        version: 22.19.1
      '@types/vscode':
        specifier: ^1.105.0
        version: 1.106.1
      typescript:
        specifier: ^5.9.3
        version: 5.9.3
packages:
  '@emnapi/core@1.7.1':
    resolution: {integrity: sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==}
  '@emnapi/runtime@1.7.1':
    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
  '@emnapi/wasi-threads@1.1.0':
    resolution: {integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==}
  '@inquirer/ansi@1.0.2':
    resolution: {integrity: sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==}
    engines: {node: '>=18'}
  '@inquirer/checkbox@4.3.2':
    resolution: {integrity: sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/confirm@5.1.21':
    resolution: {integrity: sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/core@10.3.2':
    resolution: {integrity: sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/editor@4.2.23':
    resolution: {integrity: sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/expand@4.0.23':
    resolution: {integrity: sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/external-editor@1.0.3':
    resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/figures@1.0.15':
    resolution: {integrity: sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==}
    engines: {node: '>=18'}
  '@inquirer/input@4.3.1':
    resolution: {integrity: sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/number@3.0.23':
    resolution: {integrity: sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/password@4.0.23':
    resolution: {integrity: sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/prompts@7.10.1':
    resolution: {integrity: sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/rawlist@4.1.11':
    resolution: {integrity: sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/search@3.2.2':
    resolution: {integrity: sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/select@4.4.2':
    resolution: {integrity: sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@inquirer/type@3.0.10':
    resolution: {integrity: sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==}
    engines: {node: '>=18'}
    peerDependencies:
      '@types/node': '>=18'
    peerDependenciesMeta:
      '@types/node':
        optional: true
  '@napi-rs/cli@3.4.1':
    resolution: {integrity: sha512-ayhm+NfrP5Hmh7vy5pfyYm/ktYtLh2PrgdLuqHTAubO7RoO2JkUE4F991AtgYxNewwXI8+guZLxU8itV7QnDrQ==}
    engines: {node: '>= 16'}
    hasBin: true
    peerDependencies:
      '@emnapi/runtime': ^1.5.0
    peerDependenciesMeta:
      '@emnapi/runtime':
        optional: true
  '@napi-rs/cross-toolchain@1.0.3':
    resolution: {integrity: sha512-ENPfLe4937bsKVTDA6zdABx4pq9w0tHqRrJHyaGxgaPq03a2Bd1unD5XSKjXJjebsABJ+MjAv1A2OvCgK9yehg==}
    peerDependencies:
      '@napi-rs/cross-toolchain-arm64-target-aarch64': ^1.0.3
      '@napi-rs/cross-toolchain-arm64-target-armv7': ^1.0.3
      '@napi-rs/cross-toolchain-arm64-target-ppc64le': ^1.0.3
      '@napi-rs/cross-toolchain-arm64-target-s390x': ^1.0.3
      '@napi-rs/cross-toolchain-arm64-target-x86_64': ^1.0.3
      '@napi-rs/cross-toolchain-x64-target-aarch64': ^1.0.3
      '@napi-rs/cross-toolchain-x64-target-armv7': ^1.0.3
      '@napi-rs/cross-toolchain-x64-target-ppc64le': ^1.0.3
      '@napi-rs/cross-toolchain-x64-target-s390x': ^1.0.3
      '@napi-rs/cross-toolchain-x64-target-x86_64': ^1.0.3
    peerDependenciesMeta:
      '@napi-rs/cross-toolchain-arm64-target-aarch64':
        optional: true
      '@napi-rs/cross-toolchain-arm64-target-armv7':
        optional: true
      '@napi-rs/cross-toolchain-arm64-target-ppc64le':
        optional: true
      '@napi-rs/cross-toolchain-arm64-target-s390x':
        optional: true
      '@napi-rs/cross-toolchain-arm64-target-x86_64':
        optional: true
      '@napi-rs/cross-toolchain-x64-target-aarch64':
        optional: true
      '@napi-rs/cross-toolchain-x64-target-armv7':
        optional: true
      '@napi-rs/cross-toolchain-x64-target-ppc64le':
        optional: true
      '@napi-rs/cross-toolchain-x64-target-s390x':
        optional: true
      '@napi-rs/cross-toolchain-x64-target-x86_64':
        optional: true
  '@napi-rs/lzma-android-arm-eabi@1.4.5':
    resolution: {integrity: sha512-Up4gpyw2SacmyKWWEib06GhiDdF+H+CCU0LAV8pnM4aJIDqKKd5LHSlBht83Jut6frkB0vwEPmAkv4NjQ5u//Q==}
    engines: {node: '>= 10'}
    cpu: [arm]
    os: [android]
  '@napi-rs/lzma-android-arm64@1.4.5':
    resolution: {integrity: sha512-uwa8sLlWEzkAM0MWyoZJg0JTD3BkPknvejAFG2acUA1raXM8jLrqujWCdOStisXhqQjZ2nDMp3FV6cs//zjfuQ==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [android]
  '@napi-rs/lzma-darwin-arm64@1.4.5':
    resolution: {integrity: sha512-0Y0TQLQ2xAjVabrMDem1NhIssOZzF/y/dqetc6OT8mD3xMTDtF8u5BqZoX3MyPc9FzpsZw4ksol+w7DsxHrpMA==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [darwin]
  '@napi-rs/lzma-darwin-x64@1.4.5':
    resolution: {integrity: sha512-vR2IUyJY3En+V1wJkwmbGWcYiT8pHloTAWdW4pG24+51GIq+intst6Uf6D/r46citObGZrlX0QvMarOkQeHWpw==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [darwin]
  '@napi-rs/lzma-freebsd-x64@1.4.5':
    resolution: {integrity: sha512-XpnYQC5SVovO35tF0xGkbHYjsS6kqyNCjuaLQ2dbEblFRr5cAZVvsJ/9h7zj/5FluJPJRDojVNxGyRhTp4z2lw==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [freebsd]
  '@napi-rs/lzma-linux-arm-gnueabihf@1.4.5':
    resolution: {integrity: sha512-ic1ZZMoRfRMwtSwxkyw4zIlbDZGC6davC9r+2oX6x9QiF247BRqqT94qGeL5ZP4Vtz0Hyy7TEViWhx5j6Bpzvw==}
    engines: {node: '>= 10'}
    cpu: [arm]
    os: [linux]
  '@napi-rs/lzma-linux-arm64-gnu@1.4.5':
    resolution: {integrity: sha512-asEp7FPd7C1Yi6DQb45a3KPHKOFBSfGuJWXcAd4/bL2Fjetb2n/KK2z14yfW8YC/Fv6x3rBM0VAZKmJuz4tysg==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
  '@napi-rs/lzma-linux-arm64-musl@1.4.5':
    resolution: {integrity: sha512-yWjcPDgJ2nIL3KNvi4536dlT/CcCWO0DUyEOlBs/SacG7BeD6IjGh6yYzd3/X1Y3JItCbZoDoLUH8iB1lTXo3w==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
  '@napi-rs/lzma-linux-ppc64-gnu@1.4.5':
    resolution: {integrity: sha512-0XRhKuIU/9ZjT4WDIG/qnX7Xz7mSQHYZo9Gb3MP2gcvBgr6BA4zywQ9k3gmQaPn9ECE+CZg2V7DV7kT+x2pUMQ==}
    engines: {node: '>= 10'}
    cpu: [ppc64]
    os: [linux]
  '@napi-rs/lzma-linux-riscv64-gnu@1.4.5':
    resolution: {integrity: sha512-QrqDIPEUUB23GCpyQj/QFyMlr8SGxxyExeZz9OWFnHfb70kXdTLWrHS/hEI1Ru+lSbQ/6xRqeoGyQ4Aqdg+/RA==}
    engines: {node: '>= 10'}
    cpu: [riscv64]
    os: [linux]
  '@napi-rs/lzma-linux-s390x-gnu@1.4.5':
    resolution: {integrity: sha512-k8RVM5aMhW86E9H0QXdquwojew4H3SwPxbRVbl49/COJQWCUjGi79X6mYruMnMPEznZinUiT1jgKbFo2A00NdA==}
    engines: {node: '>= 10'}
    cpu: [s390x]
    os: [linux]
  '@napi-rs/lzma-linux-x64-gnu@1.4.5':
    resolution: {integrity: sha512-6rMtBgnIq2Wcl1rQdZsnM+rtCcVCbws1nF8S2NzaUsVaZv8bjrPiAa0lwg4Eqnn1d9lgwqT+cZgm5m+//K08Kw==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
  '@napi-rs/lzma-linux-x64-musl@1.4.5':
    resolution: {integrity: sha512-eiadGBKi7Vd0bCArBUOO/qqRYPHt/VQVvGyYvDFt6C2ZSIjlD+HuOl+2oS1sjf4CFjK4eDIog6EdXnL0NE6iyQ==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
  '@napi-rs/lzma-wasm32-wasi@1.4.5':
    resolution: {integrity: sha512-+VyHHlr68dvey6fXc2hehw9gHVFIW3TtGF1XkcbAu65qVXsA9D/T+uuoRVqhE+JCyFHFrO0ixRbZDRK1XJt1sA==}
    engines: {node: '>=14.0.0'}
    cpu: [wasm32]
  '@napi-rs/lzma-win32-arm64-msvc@1.4.5':
    resolution: {integrity: sha512-eewnqvIyyhHi3KaZtBOJXohLvwwN27gfS2G/YDWdfHlbz1jrmfeHAmzMsP5qv8vGB+T80TMHNkro4kYjeh6Deg==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [win32]
  '@napi-rs/lzma-win32-ia32-msvc@1.4.5':
    resolution: {integrity: sha512-OeacFVRCJOKNU/a0ephUfYZ2Yt+NvaHze/4TgOwJ0J0P4P7X1mHzN+ig9Iyd74aQDXYqc7kaCXA2dpAOcH87Cg==}
    engines: {node: '>= 10'}
    cpu: [ia32]
    os: [win32]
  '@napi-rs/lzma-win32-x64-msvc@1.4.5':
    resolution: {integrity: sha512-T4I1SamdSmtyZgDXGAGP+y5LEK5vxHUFwe8mz6D4R7Sa5/WCxTcCIgPJ9BD7RkpO17lzhlaM2vmVvMy96Lvk9Q==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [win32]
  '@napi-rs/lzma@1.4.5':
    resolution: {integrity: sha512-zS5LuN1OBPAyZpda2ZZgYOEDC+xecUdAGnrvbYzjnLXkrq/OBC3B9qcRvlxbDR3k5H/gVfvef1/jyUqPknqjbg==}
    engines: {node: '>= 10'}
  '@napi-rs/tar-android-arm-eabi@1.1.0':
    resolution: {integrity: sha512-h2Ryndraj/YiKgMV/r5by1cDusluYIRT0CaE0/PekQ4u+Wpy2iUVqvzVU98ZPnhXaNeYxEvVJHNGafpOfaD0TA==}
    engines: {node: '>= 10'}
    cpu: [arm]
    os: [android]
  '@napi-rs/tar-android-arm64@1.1.0':
    resolution: {integrity: sha512-DJFyQHr1ZxNZorm/gzc1qBNLF/FcKzcH0V0Vwan5P+o0aE2keQIGEjJ09FudkF9v6uOuJjHCVDdK6S6uHtShAw==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [android]
  '@napi-rs/tar-darwin-arm64@1.1.0':
    resolution: {integrity: sha512-Zz2sXRzjIX4e532zD6xm2SjXEym6MkvfCvL2RMpG2+UwNVDVscHNcz3d47Pf3sysP2e2af7fBB3TIoK2f6trPw==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [darwin]
  '@napi-rs/tar-darwin-x64@1.1.0':
    resolution: {integrity: sha512-EI+CptIMNweT0ms9S3mkP/q+J6FNZ1Q6pvpJOEcWglRfyfQpLqjlC0O+dptruTPE8VamKYuqdjxfqD8hifZDOA==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [darwin]
  '@napi-rs/tar-freebsd-x64@1.1.0':
    resolution: {integrity: sha512-J0PIqX+pl6lBIAckL/c87gpodLbjZB1OtIK+RDscKC9NLdpVv6VGOxzUV/fYev/hctcE8EfkLbgFOfpmVQPg2g==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [freebsd]
  '@napi-rs/tar-linux-arm-gnueabihf@1.1.0':
    resolution: {integrity: sha512-SLgIQo3f3EjkZ82ZwvrEgFvMdDAhsxCYjyoSuWfHCz0U16qx3SuGCp8+FYOPYCECHN3ZlGjXnoAIt9ERd0dEUg==}
    engines: {node: '>= 10'}
    cpu: [arm]
    os: [linux]
  '@napi-rs/tar-linux-arm64-gnu@1.1.0':
    resolution: {integrity: sha512-d014cdle52EGaH6GpYTQOP9Py7glMO1zz/+ynJPjjzYFSxvdYx0byrjumZk2UQdIyGZiJO2MEFpCkEEKFSgPYA==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
  '@napi-rs/tar-linux-arm64-musl@1.1.0':
    resolution: {integrity: sha512-L/y1/26q9L/uBqiW/JdOb/Dc94egFvNALUZV2WCGKQXc6UByPBMgdiEyW2dtoYxYYYYc+AKD+jr+wQPcvX2vrQ==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
  '@napi-rs/tar-linux-ppc64-gnu@1.1.0':
    resolution: {integrity: sha512-EPE1K/80RQvPbLRJDJs1QmCIcH+7WRi0F73+oTe1582y9RtfGRuzAkzeBuAGRXAQEjRQw/RjtNqr6UTJ+8UuWQ==}
    engines: {node: '>= 10'}
    cpu: [ppc64]
    os: [linux]
  '@napi-rs/tar-linux-s390x-gnu@1.1.0':
    resolution: {integrity: sha512-B2jhWiB1ffw1nQBqLUP1h4+J1ovAxBOoe5N2IqDMOc63fsPZKNqF1PvO/dIem8z7LL4U4bsfmhy3gBfu547oNQ==}
    engines: {node: '>= 10'}
    cpu: [s390x]
    os: [linux]
  '@napi-rs/tar-linux-x64-gnu@1.1.0':
    resolution: {integrity: sha512-tbZDHnb9617lTnsDMGo/eAMZxnsQFnaRe+MszRqHguKfMwkisc9CCJnks/r1o84u5fECI+J/HOrKXgczq/3Oww==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
  '@napi-rs/tar-linux-x64-musl@1.1.0':
    resolution: {integrity: sha512-dV6cODlzbO8u6Anmv2N/ilQHq/AWz0xyltuXoLU3yUyXbZcnWYZuB2rL8OBGPmqNcD+x9NdScBNXh7vWN0naSQ==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
  '@napi-rs/tar-wasm32-wasi@1.1.0':
    resolution: {integrity: sha512-jIa9nb2HzOrfH0F8QQ9g3WE4aMH5vSI5/1NYVNm9ysCmNjCCtMXCAhlI3WKCdm/DwHf0zLqdrrtDFXODcNaqMw==}
    engines: {node: '>=14.0.0'}
    cpu: [wasm32]
  '@napi-rs/tar-win32-arm64-msvc@1.1.0':
    resolution: {integrity: sha512-vfpG71OB0ijtjemp3WTdmBKJm9R70KM8vsSExMsIQtV0lVzP07oM1CW6JbNRPXNLhRoue9ofYLiUDk8bE0Hckg==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [win32]
  '@napi-rs/tar-win32-ia32-msvc@1.1.0':
    resolution: {integrity: sha512-hGPyPW60YSpOSgzfy68DLBHgi6HxkAM+L59ZZZPMQ0TOXjQg+p2EW87+TjZfJOkSpbYiEkULwa/f4a2hcVjsqQ==}
    engines: {node: '>= 10'}
    cpu: [ia32]
    os: [win32]
  '@napi-rs/tar-win32-x64-msvc@1.1.0':
    resolution: {integrity: sha512-L6Ed1DxXK9YSCMyvpR8MiNAyKNkQLjsHsHK9E0qnHa8NzLFqzDKhvs5LfnWxM2kJ+F7m/e5n9zPm24kHb3LsVw==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [win32]
  '@napi-rs/tar@1.1.0':
    resolution: {integrity: sha512-7cmzIu+Vbupriudo7UudoMRH2OA3cTw67vva8MxeoAe5S7vPFI7z0vp0pMXiA25S8IUJefImQ90FeJjl8fjEaQ==}
    engines: {node: '>= 10'}
  '@napi-rs/wasm-runtime@1.0.7':
    resolution: {integrity: sha512-SeDnOO0Tk7Okiq6DbXmmBODgOAb9dp9gjlphokTUxmt8U3liIP1ZsozBahH69j/RJv+Rfs6IwUKHTgQYJ/HBAw==}
  '@napi-rs/wasm-tools-android-arm-eabi@1.0.1':
    resolution: {integrity: sha512-lr07E/l571Gft5v4aA1dI8koJEmF1F0UigBbsqg9OWNzg80H3lDPO+auv85y3T/NHE3GirDk7x/D3sLO57vayw==}
    engines: {node: '>= 10'}
    cpu: [arm]
    os: [android]
  '@napi-rs/wasm-tools-android-arm64@1.0.1':
    resolution: {integrity: sha512-WDR7S+aRLV6LtBJAg5fmjKkTZIdrEnnQxgdsb7Cf8pYiMWBHLU+LC49OUVppQ2YSPY0+GeYm9yuZWW3kLjJ7Bg==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [android]
  '@napi-rs/wasm-tools-darwin-arm64@1.0.1':
    resolution: {integrity: sha512-qWTI+EEkiN0oIn/N2gQo7+TVYil+AJ20jjuzD2vATS6uIjVz+Updeqmszi7zq7rdFTLp6Ea3/z4kDKIfZwmR9g==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [darwin]
  '@napi-rs/wasm-tools-darwin-x64@1.0.1':
    resolution: {integrity: sha512-bA6hubqtHROR5UI3tToAF/c6TDmaAgF0SWgo4rADHtQ4wdn0JeogvOk50gs2TYVhKPE2ZD2+qqt7oBKB+sxW3A==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [darwin]
  '@napi-rs/wasm-tools-freebsd-x64@1.0.1':
    resolution: {integrity: sha512-90+KLBkD9hZEjPQW1MDfwSt5J1L46EUKacpCZWyRuL6iIEO5CgWU0V/JnEgFsDOGyyYtiTvHc5bUdUTWd4I9Vg==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [freebsd]
  '@napi-rs/wasm-tools-linux-arm64-gnu@1.0.1':
    resolution: {integrity: sha512-rG0QlS65x9K/u3HrKafDf8cFKj5wV2JHGfl8abWgKew0GVPyp6vfsDweOwHbWAjcHtp2LHi6JHoW80/MTHm52Q==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
  '@napi-rs/wasm-tools-linux-arm64-musl@1.0.1':
    resolution: {integrity: sha512-jAasbIvjZXCgX0TCuEFQr+4D6Lla/3AAVx2LmDuMjgG4xoIXzjKWl7c4chuaD+TI+prWT0X6LJcdzFT+ROKGHQ==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
  '@napi-rs/wasm-tools-linux-x64-gnu@1.0.1':
    resolution: {integrity: sha512-Plgk5rPqqK2nocBGajkMVbGm010Z7dnUgq0wtnYRZbzWWxwWcXfZMPa8EYxrK4eE8SzpI7VlZP1tdVsdjgGwMw==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
  '@napi-rs/wasm-tools-linux-x64-musl@1.0.1':
    resolution: {integrity: sha512-GW7AzGuWxtQkyHknHWYFdR0CHmW6is8rG2Rf4V6GNmMpmwtXt/ItWYWtBe4zqJWycMNazpfZKSw/BpT7/MVCXQ==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
  '@napi-rs/wasm-tools-wasm32-wasi@1.0.1':
    resolution: {integrity: sha512-/nQVSTrqSsn7YdAc2R7Ips/tnw5SPUcl3D7QrXCNGPqjbatIspnaexvaOYNyKMU6xPu+pc0BTnKVmqhlJJCPLA==}
    engines: {node: '>=14.0.0'}
    cpu: [wasm32]
  '@napi-rs/wasm-tools-win32-arm64-msvc@1.0.1':
    resolution: {integrity: sha512-PFi7oJIBu5w7Qzh3dwFea3sHRO3pojMsaEnUIy22QvsW+UJfNQwJCryVrpoUt8m4QyZXI+saEq/0r4GwdoHYFQ==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [win32]
  '@napi-rs/wasm-tools-win32-ia32-msvc@1.0.1':
    resolution: {integrity: sha512-gXkuYzxQsgkj05Zaq+KQTkHIN83dFAwMcTKa2aQcpYPRImFm2AQzEyLtpXmyCWzJ0F9ZYAOmbSyrNew8/us6bw==}
    engines: {node: '>= 10'}
    cpu: [ia32]
    os: [win32]
  '@napi-rs/wasm-tools-win32-x64-msvc@1.0.1':
    resolution: {integrity: sha512-rEAf05nol3e3eei2sRButmgXP+6ATgm0/38MKhz9Isne82T4rPIMYsCIFj0kOisaGeVwoi2fnm7O9oWp5YVnYQ==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [win32]
  '@napi-rs/wasm-tools@1.0.1':
    resolution: {integrity: sha512-enkZYyuCdo+9jneCPE/0fjIta4wWnvVN9hBo2HuiMpRF0q3lzv1J6b/cl7i0mxZUKhBrV3aCKDBQnCOhwKbPmQ==}
    engines: {node: '>= 10'}
  '@octokit/auth-token@6.0.0':
    resolution: {integrity: sha512-P4YJBPdPSpWTQ1NU4XYdvHvXJJDxM6YwpS0FZHRgP7YFkdVxsWcpWGy/NVqlAA7PcPCnMacXlRm1y2PFZRWL/w==}
    engines: {node: '>= 20'}
  '@octokit/core@7.0.6':
    resolution: {integrity: sha512-DhGl4xMVFGVIyMwswXeyzdL4uXD5OGILGX5N8Y+f6W7LhC1Ze2poSNrkF/fedpVDHEEZ+PHFW0vL14I+mm8K3Q==}
    engines: {node: '>= 20'}
  '@octokit/endpoint@11.0.2':
    resolution: {integrity: sha512-4zCpzP1fWc7QlqunZ5bSEjxc6yLAlRTnDwKtgXfcI/FxxGoqedDG8V2+xJ60bV2kODqcGB+nATdtap/XYq2NZQ==}
    engines: {node: '>= 20'}
  '@octokit/graphql@9.0.3':
    resolution: {integrity: sha512-grAEuupr/C1rALFnXTv6ZQhFuL1D8G5y8CN04RgrO4FIPMrtm+mcZzFG7dcBm+nq+1ppNixu+Jd78aeJOYxlGA==}
    engines: {node: '>= 20'}
  '@octokit/openapi-types@27.0.0':
    resolution: {integrity: sha512-whrdktVs1h6gtR+09+QsNk2+FO+49j6ga1c55YZudfEG+oKJVvJLQi3zkOm5JjiUXAagWK2tI2kTGKJ2Ys7MGA==}
  '@octokit/plugin-paginate-rest@14.0.0':
    resolution: {integrity: sha512-fNVRE7ufJiAA3XUrha2omTA39M6IXIc6GIZLvlbsm8QOQCYvpq/LkMNGyFlB1d8hTDzsAXa3OKtybdMAYsV/fw==}
    engines: {node: '>= 20'}
    peerDependencies:
      '@octokit/core': '>=6'
  '@octokit/plugin-request-log@6.0.0':
    resolution: {integrity: sha512-UkOzeEN3W91/eBq9sPZNQ7sUBvYCqYbrrD8gTbBuGtHEuycE4/awMXcYvx6sVYo7LypPhmQwwpUe4Yyu4QZN5Q==}
    engines: {node: '>= 20'}
    peerDependencies:
      '@octokit/core': '>=6'
  '@octokit/plugin-rest-endpoint-methods@17.0.0':
    resolution: {integrity: sha512-B5yCyIlOJFPqUUeiD0cnBJwWJO8lkJs5d8+ze9QDP6SvfiXSz1BF+91+0MeI1d2yxgOhU/O+CvtiZ9jSkHhFAw==}
    engines: {node: '>= 20'}
    peerDependencies:
      '@octokit/core': '>=6'
  '@octokit/request-error@7.1.0':
    resolution: {integrity: sha512-KMQIfq5sOPpkQYajXHwnhjCC0slzCNScLHs9JafXc4RAJI+9f+jNDlBNaIMTvazOPLgb4BnlhGJOTbnN0wIjPw==}
    engines: {node: '>= 20'}
  '@octokit/request@10.0.7':
    resolution: {integrity: sha512-v93h0i1yu4idj8qFPZwjehoJx4j3Ntn+JhXsdJrG9pYaX6j/XRz2RmasMUHtNgQD39nrv/VwTWSqK0RNXR8upA==}
    engines: {node: '>= 20'}
  '@octokit/rest@22.0.1':
    resolution: {integrity: sha512-Jzbhzl3CEexhnivb1iQ0KJ7s5vvjMWcmRtq5aUsKmKDrRW6z3r84ngmiFKFvpZjpiU/9/S6ITPFRpn5s/3uQJw==}
    engines: {node: '>= 20'}
  '@octokit/types@16.0.0':
    resolution: {integrity: sha512-sKq+9r1Mm4efXW1FCk7hFSeJo4QKreL/tTbR0rz/qx/r1Oa2VV83LTA/H/MuCOX7uCIJmQVRKBcbmWoySjAnSg==}
  '@tybys/wasm-util@0.10.1':
    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
  '@types/node@22.19.1':
    resolution: {integrity: sha512-LCCV0HdSZZZb34qifBsyWlUmok6W7ouER+oQIGBScS8EsZsQbrtFTUrDX4hOl+CS6p7cnNC4td+qrSVGSCTUfQ==}
  '@types/vscode@1.106.1':
    resolution: {integrity: sha512-R/HV8u2h8CAddSbX8cjpdd7B8/GnE4UjgjpuGuHcbp1xV6yh4OeqU4L1pKjlwujCrSFS0MOpwJAIs/NexMB1fQ==}
  ansi-regex@5.0.1:
    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
    engines: {node: '>=8'}
  ansi-styles@4.3.0:
    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
    engines: {node: '>=8'}
  argparse@2.0.1:
    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
  before-after-hook@4.0.0:
    resolution: {integrity: sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ==}
  chardet@2.1.1:
    resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
  cli-width@4.1.0:
    resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
    engines: {node: '>= 12'}
  clipanion@4.0.0-rc.4:
    resolution: {integrity: sha512-CXkMQxU6s9GklO/1f714dkKBMu1lopS1WFF0B8o4AxPykR1hpozxSiUZ5ZUeBjfPgCWqbcNOtZVFhB8Lkfp1+Q==}
    peerDependencies:
      typanion: '*'
  color-convert@2.0.1:
    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
    engines: {node: '>=7.0.0'}
  color-name@1.1.4:
    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
  colorette@2.0.20:
    resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
  debug@4.4.3:
    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
    engines: {node: '>=6.0'}
    peerDependencies:
      supports-color: '*'
    peerDependenciesMeta:
      supports-color:
        optional: true
  emnapi@1.7.1:
    resolution: {integrity: sha512-wlLK2xFq+T+rCBlY6+lPlFVDEyE93b7hSn9dMrfWBIcPf4ArwUvymvvMnN9M5WWuiryYQe9M+UJrkqw4trdyRA==}
    peerDependencies:
      node-addon-api: '>= 6.1.0'
    peerDependenciesMeta:
      node-addon-api:
        optional: true
  emoji-regex@8.0.0:
    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
  es-toolkit@1.42.0:
    resolution: {integrity: sha512-SLHIyY7VfDJBM8clz4+T2oquwTQxEzu263AyhVK4jREOAwJ+8eebaa4wM3nlvnAqhDrMm2EsA6hWHaQsMPQ1nA==}
  fast-content-type-parse@3.0.0:
    resolution: {integrity: sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg==}
  iconv-lite@0.7.0:
    resolution: {integrity: sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==}
    engines: {node: '>=0.10.0'}
  is-fullwidth-code-point@3.0.0:
    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
    engines: {node: '>=8'}
  js-yaml@4.1.1:
    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
    hasBin: true
  ms@2.1.3:
    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
  mute-stream@2.0.0:
    resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==}
    engines: {node: ^18.17.0 || >=20.5.0}
  safer-buffer@2.1.2:
    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
  semver@7.7.3:
    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
    engines: {node: '>=10'}
    hasBin: true
  signal-exit@4.1.0:
    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
    engines: {node: '>=14'}
  string-width@4.2.3:
    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
    engines: {node: '>=8'}
  strip-ansi@6.0.1:
    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
    engines: {node: '>=8'}
  tslib@2.8.1:
    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
  typanion@3.14.0:
    resolution: {integrity: sha512-ZW/lVMRabETuYCd9O9ZvMhAh8GslSqaUjxmK/JLPCh6l73CvLBiuXswj/+7LdnWOgYsQ130FqLzFz5aGT4I3Ug==}
  typescript@5.9.3:
    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
    engines: {node: '>=14.17'}
    hasBin: true
  undici-types@6.21.0:
    resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
  universal-user-agent@7.0.3:
    resolution: {integrity: sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A==}
  wrap-ansi@6.2.0:
    resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
    engines: {node: '>=8'}
  yoctocolors-cjs@2.1.3:
    resolution: {integrity: sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==}
    engines: {node: '>=18'}
snapshots:
  '@emnapi/core@1.7.1':
    dependencies:
      '@emnapi/wasi-threads': 1.1.0
      tslib: 2.8.1
    optional: true
  '@emnapi/runtime@1.7.1':
    dependencies:
      tslib: 2.8.1
    optional: true
  '@emnapi/wasi-threads@1.1.0':
    dependencies:
      tslib: 2.8.1
    optional: true
  '@inquirer/ansi@1.0.2': {}
  '@inquirer/checkbox@4.3.2(@types/node@22.19.1)':
    dependencies:
      '@inquirer/ansi': 1.0.2
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/figures': 1.0.15
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
      yoctocolors-cjs: 2.1.3
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/confirm@5.1.21(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/core@10.3.2(@types/node@22.19.1)':
    dependencies:
      '@inquirer/ansi': 1.0.2
      '@inquirer/figures': 1.0.15
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
      cli-width: 4.1.0
      mute-stream: 2.0.0
      signal-exit: 4.1.0
      wrap-ansi: 6.2.0
      yoctocolors-cjs: 2.1.3
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/editor@4.2.23(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/external-editor': 1.0.3(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/expand@4.0.23(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
      yoctocolors-cjs: 2.1.3
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/external-editor@1.0.3(@types/node@22.19.1)':
    dependencies:
      chardet: 2.1.1
      iconv-lite: 0.7.0
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/figures@1.0.15': {}
  '@inquirer/input@4.3.1(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/number@3.0.23(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/password@4.0.23(@types/node@22.19.1)':
    dependencies:
      '@inquirer/ansi': 1.0.2
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/prompts@7.10.1(@types/node@22.19.1)':
    dependencies:
      '@inquirer/checkbox': 4.3.2(@types/node@22.19.1)
      '@inquirer/confirm': 5.1.21(@types/node@22.19.1)
      '@inquirer/editor': 4.2.23(@types/node@22.19.1)
      '@inquirer/expand': 4.0.23(@types/node@22.19.1)
      '@inquirer/input': 4.3.1(@types/node@22.19.1)
      '@inquirer/number': 3.0.23(@types/node@22.19.1)
      '@inquirer/password': 4.0.23(@types/node@22.19.1)
      '@inquirer/rawlist': 4.1.11(@types/node@22.19.1)
      '@inquirer/search': 3.2.2(@types/node@22.19.1)
      '@inquirer/select': 4.4.2(@types/node@22.19.1)
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/rawlist@4.1.11(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
      yoctocolors-cjs: 2.1.3
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/search@3.2.2(@types/node@22.19.1)':
    dependencies:
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/figures': 1.0.15
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
      yoctocolors-cjs: 2.1.3
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/select@4.4.2(@types/node@22.19.1)':
    dependencies:
      '@inquirer/ansi': 1.0.2
      '@inquirer/core': 10.3.2(@types/node@22.19.1)
      '@inquirer/figures': 1.0.15
      '@inquirer/type': 3.0.10(@types/node@22.19.1)
      yoctocolors-cjs: 2.1.3
    optionalDependencies:
      '@types/node': 22.19.1
  '@inquirer/type@3.0.10(@types/node@22.19.1)':
    optionalDependencies:
      '@types/node': 22.19.1
  '@napi-rs/cli@3.4.1(@emnapi/runtime@1.7.1)(@types/node@22.19.1)':
    dependencies:
      '@inquirer/prompts': 7.10.1(@types/node@22.19.1)
      '@napi-rs/cross-toolchain': 1.0.3
      '@napi-rs/wasm-tools': 1.0.1
      '@octokit/rest': 22.0.1
      clipanion: 4.0.0-rc.4(typanion@3.14.0)
      colorette: 2.0.20
      debug: 4.4.3
      emnapi: 1.7.1
      es-toolkit: 1.42.0
      js-yaml: 4.1.1
      semver: 7.7.3
      typanion: 3.14.0
    optionalDependencies:
      '@emnapi/runtime': 1.7.1
    transitivePeerDependencies:
      - '@napi-rs/cross-toolchain-arm64-target-aarch64'
      - '@napi-rs/cross-toolchain-arm64-target-armv7'
      - '@napi-rs/cross-toolchain-arm64-target-ppc64le'
      - '@napi-rs/cross-toolchain-arm64-target-s390x'
      - '@napi-rs/cross-toolchain-arm64-target-x86_64'
      - '@napi-rs/cross-toolchain-x64-target-aarch64'
      - '@napi-rs/cross-toolchain-x64-target-armv7'
      - '@napi-rs/cross-toolchain-x64-target-ppc64le'
      - '@napi-rs/cross-toolchain-x64-target-s390x'
      - '@napi-rs/cross-toolchain-x64-target-x86_64'
      - '@types/node'
      - node-addon-api
      - supports-color
  '@napi-rs/cross-toolchain@1.0.3':
    dependencies:
      '@napi-rs/lzma': 1.4.5
      '@napi-rs/tar': 1.1.0
      debug: 4.4.3
    transitivePeerDependencies:
      - supports-color
  '@napi-rs/lzma-android-arm-eabi@1.4.5':
    optional: true
  '@napi-rs/lzma-android-arm64@1.4.5':
    optional: true
  '@napi-rs/lzma-darwin-arm64@1.4.5':
    optional: true
  '@napi-rs/lzma-darwin-x64@1.4.5':
    optional: true
  '@napi-rs/lzma-freebsd-x64@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-arm-gnueabihf@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-arm64-gnu@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-arm64-musl@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-ppc64-gnu@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-riscv64-gnu@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-s390x-gnu@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-x64-gnu@1.4.5':
    optional: true
  '@napi-rs/lzma-linux-x64-musl@1.4.5':
    optional: true
  '@napi-rs/lzma-wasm32-wasi@1.4.5':
    dependencies:
      '@napi-rs/wasm-runtime': 1.0.7
    optional: true
  '@napi-rs/lzma-win32-arm64-msvc@1.4.5':
    optional: true
  '@napi-rs/lzma-win32-ia32-msvc@1.4.5':
    optional: true
  '@napi-rs/lzma-win32-x64-msvc@1.4.5':
    optional: true
  '@napi-rs/lzma@1.4.5':
    optionalDependencies:
      '@napi-rs/lzma-android-arm-eabi': 1.4.5
      '@napi-rs/lzma-android-arm64': 1.4.5
      '@napi-rs/lzma-darwin-arm64': 1.4.5
      '@napi-rs/lzma-darwin-x64': 1.4.5
      '@napi-rs/lzma-freebsd-x64': 1.4.5
      '@napi-rs/lzma-linux-arm-gnueabihf': 1.4.5
      '@napi-rs/lzma-linux-arm64-gnu': 1.4.5
      '@napi-rs/lzma-linux-arm64-musl': 1.4.5
      '@napi-rs/lzma-linux-ppc64-gnu': 1.4.5
      '@napi-rs/lzma-linux-riscv64-gnu': 1.4.5
      '@napi-rs/lzma-linux-s390x-gnu': 1.4.5
      '@napi-rs/lzma-linux-x64-gnu': 1.4.5
      '@napi-rs/lzma-linux-x64-musl': 1.4.5
      '@napi-rs/lzma-wasm32-wasi': 1.4.5
      '@napi-rs/lzma-win32-arm64-msvc': 1.4.5
      '@napi-rs/lzma-win32-ia32-msvc': 1.4.5
      '@napi-rs/lzma-win32-x64-msvc': 1.4.5
  '@napi-rs/tar-android-arm-eabi@1.1.0':
    optional: true
  '@napi-rs/tar-android-arm64@1.1.0':
    optional: true
  '@napi-rs/tar-darwin-arm64@1.1.0':
    optional: true
  '@napi-rs/tar-darwin-x64@1.1.0':
    optional: true
  '@napi-rs/tar-freebsd-x64@1.1.0':
    optional: true
  '@napi-rs/tar-linux-arm-gnueabihf@1.1.0':
    optional: true
  '@napi-rs/tar-linux-arm64-gnu@1.1.0':
    optional: true
  '@napi-rs/tar-linux-arm64-musl@1.1.0':
    optional: true
  '@napi-rs/tar-linux-ppc64-gnu@1.1.0':
    optional: true
  '@napi-rs/tar-linux-s390x-gnu@1.1.0':
    optional: true
  '@napi-rs/tar-linux-x64-gnu@1.1.0':
    optional: true
  '@napi-rs/tar-linux-x64-musl@1.1.0':
    optional: true
  '@napi-rs/tar-wasm32-wasi@1.1.0':
    dependencies:
      '@napi-rs/wasm-runtime': 1.0.7
    optional: true
  '@napi-rs/tar-win32-arm64-msvc@1.1.0':
    optional: true
  '@napi-rs/tar-win32-ia32-msvc@1.1.0':
    optional: true
  '@napi-rs/tar-win32-x64-msvc@1.1.0':
    optional: true
  '@napi-rs/tar@1.1.0':
    optionalDependencies:
      '@napi-rs/tar-android-arm-eabi': 1.1.0
      '@napi-rs/tar-android-arm64': 1.1.0
      '@napi-rs/tar-darwin-arm64': 1.1.0
      '@napi-rs/tar-darwin-x64': 1.1.0
      '@napi-rs/tar-freebsd-x64': 1.1.0
      '@napi-rs/tar-linux-arm-gnueabihf': 1.1.0
      '@napi-rs/tar-linux-arm64-gnu': 1.1.0
      '@napi-rs/tar-linux-arm64-musl': 1.1.0
      '@napi-rs/tar-linux-ppc64-gnu': 1.1.0
      '@napi-rs/tar-linux-s390x-gnu': 1.1.0
      '@napi-rs/tar-linux-x64-gnu': 1.1.0
      '@napi-rs/tar-linux-x64-musl': 1.1.0
      '@napi-rs/tar-wasm32-wasi': 1.1.0
      '@napi-rs/tar-win32-arm64-msvc': 1.1.0
      '@napi-rs/tar-win32-ia32-msvc': 1.1.0
      '@napi-rs/tar-win32-x64-msvc': 1.1.0
  '@napi-rs/wasm-runtime@1.0.7':
    dependencies:
      '@emnapi/core': 1.7.1
      '@emnapi/runtime': 1.7.1
      '@tybys/wasm-util': 0.10.1
    optional: true
  '@napi-rs/wasm-tools-android-arm-eabi@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-android-arm64@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-darwin-arm64@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-darwin-x64@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-freebsd-x64@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-linux-arm64-gnu@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-linux-arm64-musl@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-linux-x64-gnu@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-linux-x64-musl@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-wasm32-wasi@1.0.1':
    dependencies:
      '@napi-rs/wasm-runtime': 1.0.7
    optional: true
  '@napi-rs/wasm-tools-win32-arm64-msvc@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-win32-ia32-msvc@1.0.1':
    optional: true
  '@napi-rs/wasm-tools-win32-x64-msvc@1.0.1':
    optional: true
  '@napi-rs/wasm-tools@1.0.1':
    optionalDependencies:
      '@napi-rs/wasm-tools-android-arm-eabi': 1.0.1
      '@napi-rs/wasm-tools-android-arm64': 1.0.1
      '@napi-rs/wasm-tools-darwin-arm64': 1.0.1
      '@napi-rs/wasm-tools-darwin-x64': 1.0.1
      '@napi-rs/wasm-tools-freebsd-x64': 1.0.1
      '@napi-rs/wasm-tools-linux-arm64-gnu': 1.0.1
      '@napi-rs/wasm-tools-linux-arm64-musl': 1.0.1
      '@napi-rs/wasm-tools-linux-x64-gnu': 1.0.1
      '@napi-rs/wasm-tools-linux-x64-musl': 1.0.1
      '@napi-rs/wasm-tools-wasm32-wasi': 1.0.1
      '@napi-rs/wasm-tools-win32-arm64-msvc': 1.0.1
      '@napi-rs/wasm-tools-win32-ia32-msvc': 1.0.1
      '@napi-rs/wasm-tools-win32-x64-msvc': 1.0.1
  '@octokit/auth-token@6.0.0': {}
  '@octokit/core@7.0.6':
    dependencies:
      '@octokit/auth-token': 6.0.0
      '@octokit/graphql': 9.0.3
      '@octokit/request': 10.0.7
      '@octokit/request-error': 7.1.0
      '@octokit/types': 16.0.0
      before-after-hook: 4.0.0
      universal-user-agent: 7.0.3
  '@octokit/endpoint@11.0.2':
    dependencies:
      '@octokit/types': 16.0.0
      universal-user-agent: 7.0.3
  '@octokit/graphql@9.0.3':
    dependencies:
      '@octokit/request': 10.0.7
      '@octokit/types': 16.0.0
      universal-user-agent: 7.0.3
  '@octokit/openapi-types@27.0.0': {}
  '@octokit/plugin-paginate-rest@14.0.0(@octokit/core@7.0.6)':
    dependencies:
      '@octokit/core': 7.0.6
      '@octokit/types': 16.0.0
  '@octokit/plugin-request-log@6.0.0(@octokit/core@7.0.6)':
    dependencies:
      '@octokit/core': 7.0.6
  '@octokit/plugin-rest-endpoint-methods@17.0.0(@octokit/core@7.0.6)':
    dependencies:
      '@octokit/core': 7.0.6
      '@octokit/types': 16.0.0
  '@octokit/request-error@7.1.0':
    dependencies:
      '@octokit/types': 16.0.0
  '@octokit/request@10.0.7':
    dependencies:
      '@octokit/endpoint': 11.0.2
      '@octokit/request-error': 7.1.0
      '@octokit/types': 16.0.0
      fast-content-type-parse: 3.0.0
      universal-user-agent: 7.0.3
  '@octokit/rest@22.0.1':
    dependencies:
      '@octokit/core': 7.0.6
      '@octokit/plugin-paginate-rest': 14.0.0(@octokit/core@7.0.6)
      '@octokit/plugin-request-log': 6.0.0(@octokit/core@7.0.6)
      '@octokit/plugin-rest-endpoint-methods': 17.0.0(@octokit/core@7.0.6)
  '@octokit/types@16.0.0':
    dependencies:
      '@octokit/openapi-types': 27.0.0
  '@tybys/wasm-util@0.10.1':
    dependencies:
      tslib: 2.8.1
    optional: true
  '@types/node@22.19.1':
    dependencies:
      undici-types: 6.21.0
  '@types/vscode@1.106.1': {}
  ansi-regex@5.0.1: {}
  ansi-styles@4.3.0:
    dependencies:
      color-convert: 2.0.1
  argparse@2.0.1: {}
  before-after-hook@4.0.0: {}
  chardet@2.1.1: {}
  cli-width@4.1.0: {}
  clipanion@4.0.0-rc.4(typanion@3.14.0):
    dependencies:
      typanion: 3.14.0
  color-convert@2.0.1:
    dependencies:
      color-name: 1.1.4
  color-name@1.1.4: {}
  colorette@2.0.20: {}
  debug@4.4.3:
    dependencies:
      ms: 2.1.3
  emnapi@1.7.1: {}
  emoji-regex@8.0.0: {}
  es-toolkit@1.42.0: {}
  fast-content-type-parse@3.0.0: {}
  iconv-lite@0.7.0:
    dependencies:
      safer-buffer: 2.1.2
  is-fullwidth-code-point@3.0.0: {}
  js-yaml@4.1.1:
    dependencies:
      argparse: 2.0.1
  ms@2.1.3: {}
  mute-stream@2.0.0: {}
  safer-buffer@2.1.2: {}
  semver@7.7.3: {}
  signal-exit@4.1.0: {}
  string-width@4.2.3:
    dependencies:
      emoji-regex: 8.0.0
      is-fullwidth-code-point: 3.0.0
      strip-ansi: 6.0.1
  strip-ansi@6.0.1:
    dependencies:
      ansi-regex: 5.0.1
  tslib@2.8.1:
    optional: true
  typanion@3.14.0: {}
  typescript@5.9.3: {}
  undici-types@6.21.0: {}
  universal-user-agent@7.0.3: {}
  wrap-ansi@6.2.0:
    dependencies:
      ansi-styles: 4.3.0
      string-width: 4.2.3
      strip-ansi: 6.0.1
  yoctocolors-cjs@2.1.3: {}