#[doc(inline)]
pub use data_encoding;

  "data-encoding/std",

[dependencies.data-encoding]
workspace = true
default-features = false
features = ["alloc"]

        text_content: text_editor::Content,
        // TODO: use pijul pijul::text_changes::Encoding (not exposed yet)
        // encoding: Encoding,

        content: FileEditorContent,

const MAX_LEN_BASE64_DISPLAY: usize = 4096;

enum FileEditorContent {
    Decoded(text_editor::Content),
    /// Short byte sequence of unknown encoding encoded with base64 for display.
    /// Must be shorter than [`MAX_LEN_BASE64_DISPLAY`]
    ShortBase64(String),
    UnknownEncoding,
}
#[derive(Debug)]

    LoadedUntrackedFile { path: String, data: Vec<u8> },

    LoadedUntrackedFile {
        path: String,
        data: Vec<u8>,
        encoding: Option<pijul::Encoding>,
    },

        Message::LoadedUntrackedFile { path, data } => {
            // TODO: use encoding
            let text_content = text_editor::Content::with_text(
                str::from_utf8(&data).unwrap_or("Not UTF-8"),
            );

        Message::LoadedUntrackedFile {
            path,
            data,
            encoding,
        } => {
            let content = match encoding {
                Some(encoding) => {
                    let decoded = encoding.decode(&data);
                    FileEditorContent::Decoded(text_editor::Content::with_text(
                        &decoded,
                    ))
                }
                None => {
                    if data.len() <= MAX_LEN_BASE64_DISPLAY {
                        let encoded =
                            format!("b{}", data_encoding::BASE64.encode(&data));
                        FileEditorContent::ShortBase64(encoded)
                    } else {
                        FileEditorContent::UnknownEncoding
                    }
                }
            };

                                text_content,

                                content,

                    ..

                    content: _,

                                text_content,

                                content,

                    text_content,

                    content: FileEditorContent::Decoded(content),

                    text_content.perform(action);

                    content.perform(action);

        let encoding = pijul::change::get_encoding(&data);

            encoding,

                        text_content,
                    }) if loaded_path == path => el(text_editor(text_content)

                        content,
                    }) if loaded_path == path => match content {
                        FileEditorContent::Decoded(content) => el(text_editor(
                            content,
                        )

                        FileEditorContent::ShortBase64(content) => {
                            el(text(content))
                        }
                        FileEditorContent::UnknownEncoding => {
                            el("Unknown encoding")
                        }
                    },

                el(text("Changed:")),

                el(text("Changes:")),

[workspace.dependencies.data-encoding]
version = "2"
default-features = false

version = "2.6.0"

version = "2.8.0"

checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"

checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"

 "data-encoding",