//! This file was generated automatically by crowbook-localize.
//! It is probably not a good idea to edit it manually.
//!
//! # Usage:
//!
//! ```rust, no_run
//! #[macro_use] mod localize_macros;
//! use localize_macros::set_lang;
//! set_lang("en");
//! lformat!("Hello, {}", name);
//! set_lang("fr");
//! lformat!("Hello, {}", name);
//! ```

use std::sync::RwLock;
use std::sync::RwLockReadGuard;

lazy_static! {
    pub static ref LANG: RwLock<String> = RwLock::new(String::from("en"));
}

/// Sets the lang
pub fn set_lang<S>(lang: S)
    where S: Into<String> {
    *LANG.write().unwrap() = lang.into();
}

/// Get the lang (or a guard on it)
///
/// This function should not be used directly
#[doc(hidden)]
pub fn __get_lang() -> RwLockReadGuard<'static, String> {
    LANG.read().unwrap()
}

/// Localized format macro (or `lformat!` in short)
/// Should be similar to `format!`, except strings are localized
/// Generated automatically, you should not edit it.
#[macro_export] macro_rules! lformat {
    ("EPUB: could not guess the format of {file} based on extension. Assuming png.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("EPUB: impossible de deviner le format de {file} à partir de son extension. On part sur du png.", $($arg)*),
            _ => format!("EPUB: could not guess the format of {file} based on extension. Assuming png.", $($arg)*),
        }
    });
    ("Error initializing book: could not set {key} to {value}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur à l'initialisation du livre: impossible de positionner {key} à {value} : {error}", $($arg)*),
            _ => format!("Error initializing book: could not set {key} to {value}: {error}", $($arg)*),
        }
    });
    ("rendering 'html.footer' template:\n{error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("dans le rendu du template 'html.footer' :\n{error}", $($arg)*),
            _ => format!("rendering 'html.footer' template:\n{error}", $($arg)*),
        }
    });
    ("- **`{key}`**\n    - **type**: {option_type}\n    - **default value**: `{default}`\n    - {comment}\n", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("- **`{key}`**\n    - **type** : {option_type}\n    - **valeur par défaut** : `{default}`\n    - {comment}\n", $($arg)*),
            _ => format!("- **`{key}`**\n    - **type**: {option_type}\n    - **default value**: `{default}`\n    - {comment}\n", $($arg)*),
        }
    });
    ("Error running grammar check on {file}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans la véfirication grammaticale de {file} : {error}", $($arg)*),
            _ => format!("Error running grammar check on {file}: {error}", $($arg)*),
        }
    });
    ("{:?} is not a bool", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{:?} n'est pas un booléen", $($arg)*),
            _ => format!("{:?} is not a bool", $($arg)*),
        }
    });
    ("could not parse {file} as a book file.\nMaybe you meant to run crowbook with the --single argument?", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'analyser {file} comme un ficheir de livre.\nPeut-être que vous vouliez lancer crowbook avec l'argument --single ?", $($arg)*),
            _ => format!("could not parse {file} as a book file.\nMaybe you meant to run crowbook with the --single argument?", $($arg)*),
        }
    });
    ("Expected a String as a key, found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Une String était attendue comme clé, pas {:?}", $($arg)*),
            _ => format!("Expected a String as a key, found {:?}", $($arg)*),
        }
    });
    ("Could not find file '{file}' for {description}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Impossible de trouver le fichier '{file}' pour {description}", $($arg)*),
            _ => format!("Could not find file '{file}' for {description}", $($arg)*),
        }
    });
    ("{error}. Proceeding without checking grammar.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{error}. On poursuit sans vérifier la grammaire.", $($arg)*),
            _ => format!("{error}. Proceeding without checking grammar.", $($arg)*),
        }
    });
    ("{:?} is not a f32", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{:?} n'est pas un f32", $($arg)*),
            _ => format!("{:?} is not a f32", $($arg)*),
        }
    });
    ("could not read response: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de lire la réponse : {error}", $($arg)*),
            _ => format!("could not read response: {error}", $($arg)*),
        }
    });
    ("could not parse '{value}' as a float for key '{key}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'analyser '{value}' comme un flottant pour la clé '{key}'", $($arg)*),
            _ => format!("could not parse '{value}' as a float for key '{key}'", $($arg)*),
        }
    });
    ("Successfully generated HTML file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier HTML généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated HTML file {file}", $($arg)*),
        }
    });
    ("Created {}, now you'll have to complete it!", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{} a été crée, maintenant vous n'avez plus qu'à le compléter !", $($arg)*),
            _ => format!("Created {}, now you'll have to complete it!", $($arg)*),
        }
    });
    ("couldn't interpret LANG: {}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'interpéter LANG: {}", $($arg)*),
            _ => format!("couldn't interpret LANG: {}", $($arg)*),
        }
    });
    ("could not create temporary directory in {path}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le répertoire temporaire dans {path}'", $($arg)*),
            _ => format!("could not create temporary directory in {path}", $($arg)*),
        }
    });
    ("expected a string as value containing a char for key '{}', found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("une chaîne de caractère contenant un caractère comme valeur pour la clé '{}', pas {:?}", $($arg)*),
            _ => format!("expected a string as value containing a char for key '{}', found {:?}", $($arg)*),
        }
    });
    ("could not render `{key}` for metadata:\n{error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de faire le rendu de `{key}` comme metadonnée :\n{error}", $($arg)*),
            _ => format!("could not render `{key}` for metadata:\n{error}", $($arg)*),
        }
    });
    ("Yaml file for language {lang} didn't contain a hash", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le fichier YAML pour le langage {lang} no contient pas de hashmap", $($arg)*),
            _ => format!("Yaml file for language {lang} didn't contain a hash", $($arg)*),
        }
    });
    ("this version of Crowbook has been compiled without support for proofreading, not generating {path}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("cette version de Crowbook a été compilée sans le support pour la relecture, {path} ne sera pas généré", $($arg)*),
            _ => format!("this version of Crowbook has been compiled without support for proofreading, not generating {path}", $($arg)*),
        }
    });
    ("option '{key}' is not present", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("l'option '{key}' n'est pas présente", $($arg)*),
            _ => format!("option '{key}' is not present", $($arg)*),
        }
    });
    ("could not parse '{value}' as a char: does not contain exactly one char", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'analyser '{value}' comme un caractère : ne contient pas exactement un caractère ", $($arg)*),
            _ => format!("could not parse '{value}' as a char: does not contain exactly one char", $($arg)*),
        }
    });
    ("Ill-formatted OPTIONS string: unrecognized type '{option_type}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chaîne OPTIONS mal formatée : type non reconnu '{option_type}'", $($arg)*),
            _ => format!("Ill-formatted OPTIONS string: unrecognized type '{option_type}'", $($arg)*),
        }
    });
    ("Successfully generated HTML file: {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier HTML généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated HTML file: {file}", $($arg)*),
        }
    });
    ("Ignoring YAML block:\n---\n{block}---", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Bloc YAML ignoré:\n---\n{block}---", $($arg)*),
            _ => format!("Ignoring YAML block:\n---\n{block}---", $($arg)*),
        }
    });
    ("Parsing chapter: {file}...", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Analyse du chapitre: {file}...", $($arg)*),
            _ => format!("Parsing chapter: {file}...", $($arg)*),
        }
    });
    ("file {file} contains invalid UTF-8", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier {file} contient de l'UTF-8 invalide", $($arg)*),
            _ => format!("file {file} contains invalid UTF-8", $($arg)*),
        }
    });
    ("rendering 'html.header' template:\n{error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("dans le rendu du template 'html.header' :\n{error}", $($arg)*),
            _ => format!("rendering 'html.header' template:\n{error}", $($arg)*),
        }
    });
    ("Inline YAML block replaced {:?} previously set to {:?} to {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le bloc YAML en ligne a remplacé {:?} qui était précédemment {:?} vers {:?}", $($arg)*),
            _ => format!("Inline YAML block replaced {:?} previously set to {:?} to {:?}", $($arg)*),
        }
    });
    ("You must pass the file of a book configuration file.\n\n{}\n\nFor more information try --help.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Vous devez passer le nom de fichier d'un livre.\n\n{}\n\nPour plus d'informations, essayez --help.", $($arg)*),
            _ => format!("You must pass the file of a book configuration file.\n\n{}\n\nFor more information try --help.", $($arg)*),
        }
    });
    ("{} is not a valid template name.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{} n'est pas un nom de template valide.", $($arg)*),
            _ => format!("{} is not a valid template name.", $($arg)*),
        }
    });
    ("problem when writing to LaTeX file: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("problème en écrivant dans le fichier LaTeX : {error}", $($arg)*),
            _ => format!("problem when writing to LaTeX file: {error}", $($arg)*),
        }
    });
    ("could not create file {file}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le fichier {file} : {error}", $($arg)*),
            _ => format!("could not create file {file}: {error}", $($arg)*),
        }
    });
    ("Could not find translation for {key} in language {lang}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Impossible de trouver une traduction pour {key} dans la langue {lang}", $($arg)*),
            _ => format!("Could not find translation for {key} in language {lang}", $($arg)*),
        }
    });
    ("Trying to run grammar check on {file}, this might take a while...", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("On essaie de vérifier la grammaire de {file}, cela peut prendre un moment...", $($arg)*),
            _ => format!("Trying to run grammar check on {file}, this might take a while...", $($arg)*),
        }
    });
    ("file {file} contains invalid UTF-8, could not parse it", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier {file} contient de l'UTF-8 invalide, impossible de l'analyser", $($arg)*),
            _ => format!("file {file} contains invalid UTF-8, could not parse it", $($arg)*),
        }
    });
    ("Error compiling template: {template}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans la compilation du template : {template}", $($arg)*),
            _ => format!("Error compiling template: {template}", $($arg)*),
        }
    });
    ("YAML block was not valid YAML: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le bloc YAML n'était pas valide : {error}", $($arg)*),
            _ => format!("YAML block was not valid YAML: {error}", $($arg)*),
        }
    });
    ("LaTeX ({source}): image '{url}' doesn't seem to be local; ignoring it.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("LaTeX ({source}) : l'image '{url}' n'a pas l'air d'être locale, elle sera ignorée", $($arg)*),
            _ => format!("LaTeX ({source}): image '{url}' doesn't seem to be local; ignoring it.", $($arg)*),
        }
    });
    ("{:?} is not an i32", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{:?} n'est pas un i32", $($arg)*),
            _ => format!("{:?} is not an i32", $($arg)*),
        }
    });
    ("ignored annotation {:?} as it wasn't compatible with the Markdown structure", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("annotation {:?} ignorée car non compatible avec la structure Markdown", $($arg)*),
            _ => format!("ignored annotation {:?} as it wasn't compatible with the Markdown structure", $($arg)*),
        }
    });
    ("Successfully generated EPUB file: {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier EPUB généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated EPUB file: {file}", $($arg)*),
        }
    });
    ("Successfully generated ODT file: {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier ODT généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated ODT file: {file}", $($arg)*),
        }
    });
    ("Could not create file '{}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Impossible de créer le fichier '{}'", $($arg)*),
            _ => format!("Could not create file '{}'", $($arg)*),
        }
    });
    ("Resources: book includes image {file} which doesn't have an extension", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Resources: le livre inclut l'image {file} qui n'a pas d'extension", $($arg)*),
            _ => format!("Resources: book includes image {file} which doesn't have an extension", $($arg)*),
        }
    });
    ("this version of Crowbook has been compiled without support for proofreading, not generating LaTeX file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("cette version de Crowbook a été compilée sans le support de la relecture, le fichier LaTeX {file} ne sera pas généré", $($arg)*),
            _ => format!("this version of Crowbook has been compiled without support for proofreading, not generating LaTeX file {file}", $($arg)*),
        }
    });
    ("Resources: book includes non-local image {file}, which might cause problem for proper inclusion.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ressources : le livre inclut l'image non-locale {file}, ce qui risque de causer des problèmes pour une inclusion correcte", $($arg)*),
            _ => format!("Resources: book includes non-local image {file}, which might cause problem for proper inclusion.", $($arg)*),
        }
    });
    ("value '{value}' for key '{key}' does not contain one and only one YAML value", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("la valeur '{value}' pour la clé '{key}' ne contient pas une et une seule valeur YAML", $($arg)*),
            _ => format!("value '{value}' for key '{key}' does not contain one and only one YAML value", $($arg)*),
        }
    });
    ("Expected a string as value for key {}, found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Une chaîne de caractères était attendue pour la clé {}, pas {:?}", $($arg)*),
            _ => format!("Expected a string as value for key {}, found {:?}", $($arg)*),
        }
    });
    ("command didn't return succesfully: {output}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("la commande ne s'est pas terminée avec succès : {output}", $($arg)*),
            _ => format!("command didn't return succesfully: {output}", $($arg)*),
        }
    });
    ("{path} already exists and is not a directory", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{path} existe déjà et n'est pas un répertoire", $($arg)*),
            _ => format!("{path} already exists and is not a directory", $($arg)*),
        }
    });
    ("problem when writing to HTML file: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("problème en écrivant dans le fichier HTML : {error}", $($arg)*),
            _ => format!("problem when writing to HTML file: {error}", $($arg)*),
        }
    });
    ("expected an integer as value for key '{}', found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("un entier était attendu comme valeur pour la clé '{}', pas {:?}", $($arg)*),
            _ => format!("expected an integer as value for key '{}', found {:?}", $($arg)*),
        }
    });
    ("Error rendering {name}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans le rendu de {name} : {error}", $($arg)*),
            _ => format!("Error rendering {name}: {error}", $($arg)*),
        }
    });
    ("error in epub rendering: {path} is neither a file nor a directory", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("erreur dans le rendu EPUB : {path} n'est ni un fichier ni un répertoire", $($arg)*),
            _ => format!("error in epub rendering: {path} is neither a file nor a directory", $($arg)*),
        }
    });
    ("can't get '{key}' as a list of files, only valid if key is resources.files", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de traiter '{key}' comme une liste de fichiers, c'est seulement valide si la clé est resources.files", $($arg)*),
            _ => format!("can't get '{key}' as a list of files, only valid if key is resources.files", $($arg)*),
        }
    });
    ("file '{file}' could not be read", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier '{file}' n'a pas pu être lu", $($arg)*),
            _ => format!("file '{file}' could not be read", $($arg)*),
        }
    });
    ("failed to execute process: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le processus n'a pas pu être exécuté : {error}", $($arg)*),
            _ => format!("failed to execute process: {error}", $($arg)*),
        }
    });
    ("file {file} refers to an absolute or a parent path.\nThis is forbidden because we are supposed to create a temporary file in a temporary dir.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier {file} fait référence à un chemin parent ou absolu.\nC'est interdit car on est censé créer un fichier temporaire dans un répertoire temporaire.", $($arg)*),
            _ => format!("file {file} refers to an absolute or a parent path.\nThis is forbidden because we are supposed to create a temporary file in a temporary dir.", $($arg)*),
        }
    });
    ("expected a float as value for key '{}', found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("un flottant était attendu comme valeur pour la clé '{}', pas {:?}", $($arg)*),
            _ => format!("expected a float as value for key '{}', found {:?}", $($arg)*),
        }
    });
    ("could not write to temporary file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'écrire dans le fichier temporaire {file}", $($arg)*),
            _ => format!("could not write to temporary file {file}", $($arg)*),
        }
    });
    ("No output file specified, and book doesn't specify an output file for {}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Pas de fichier de sortie spécifié, et le livre n'en spécifie pas pour {}", $($arg)*),
            _ => format!("No output file specified, and book doesn't specify an output file for {}", $($arg)*),
        }
    });
    ("could not parse '{value}' as a valid YAML value", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'analyser '{value}' comme une valeur YAML valide", $($arg)*),
            _ => format!("could not parse '{value}' as a valid YAML value", $($arg)*),
        }
    });
    ("could not create file '{file}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le fichier '{file}'", $($arg)*),
            _ => format!("could not create file '{file}'", $($arg)*),
        }
    });
    ("Could not create file {}: it already exists!", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Impossible de créer le fichier {} : il existe déjà !", $($arg)*),
            _ => format!("Could not create file {}: it already exists!", $($arg)*),
        }
    });
    ("Resources: could not find a in-book match for link {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ressources: impossible de trouver une correspondance à l'intérieur du livre pour le lien {file}", $($arg)*),
            _ => format!("Resources: could not find a in-book match for link {file}", $($arg)*),
        }
    });
    ("this version of Crowbook has been compiled without support for proofreading,not generating HTML file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("cette version de Crowbook a été compilée sans le support de la relecture, le fichier HTML {file} ne sera pas généré", $($arg)*),
            _ => format!("this version of Crowbook has been compiled without support for proofreading,not generating HTML file {file}", $($arg)*),
        }
    });
    ("{:?} is not a char", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{:?} n'est pas un caractère", $($arg)*),
            _ => format!("{:?} is not a char", $($arg)*),
        }
    });
    ("could not create HTML directory {path}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le répertoire HTML {path} : {error}", $($arg)*),
            _ => format!("could not create HTML directory {path}: {error}", $($arg)*),
        }
    });
    ("footnote reference {reference} does not have a matching definition", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("la référence à la note de pas de page {reference} n'a pas de définition correspondante", $($arg)*),
            _ => format!("footnote reference {reference} does not have a matching definition", $($arg)*),
        }
    });
    ("could not decode JSON: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le format JSON : {error}", $($arg)*),
            _ => format!("could not decode JSON: {error}", $($arg)*),
        }
    });
    ("Successfully generated PDF file for proofreading: {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier PDF pour la relecture généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated PDF file for proofreading: {file}", $($arg)*),
        }
    });
    ("Error parsing markdown: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans l'analyse du Markdown : {error}", $($arg)*),
            _ => format!("Error parsing markdown: {error}", $($arg)*),
        }
    });
    ("could not create temporary file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le fichier temporaire {file}", $($arg)*),
            _ => format!("could not create temporary file {file}", $($arg)*),
        }
    });
    ("could not copy file {input} to {output}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer le fichier de {input} à {output}", $($arg)*),
            _ => format!("could not copy file {input} to {output}", $($arg)*),
        }
    });
    ("error while reading image file: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("erreur en lisant le fichier image : {error}", $($arg)*),
            _ => format!("error while reading image file: {error}", $($arg)*),
        }
    });
    ("Inline YAML block set {:?} to {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le bloc YAML en ligne a positionné {:?} à {:?}", $($arg)*),
            _ => format!("Inline YAML block set {:?} to {:?}", $($arg)*),
        }
    });
    ("Warning: book contains chapter '{file}' in a directory above the book file, this might cause problems", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Avertissement: le livre contient un chapitre '{file}' dans un répertoire au-dessus du fichier du livre, cela risque de causer des problèmes", $($arg)*),
            _ => format!("Warning: book contains chapter '{file}' in a directory above the book file, this might cause problems", $($arg)*),
        }
    });
    ("this version of Crowbook has been compiled without support for proofreading, not generating {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("cette version de Crowbook a été compilée sans le support pour la relecture, {file} ne sera pas généré", $($arg)*),
            _ => format!("this version of Crowbook has been compiled without support for proofreading, not generating {file}", $($arg)*),
        }
    });
    ("Found something that looked like a YAML block:\n{block}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Trouvé quelque chose qui ressemblait à un bloc YAML :\n{block}", $($arg)*),
            _ => format!("Found something that looked like a YAML block:\n{block}", $($arg)*),
        }
    });
    ("ODT: footnotes are not yet implemented in this format, ignoring {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("ODT: les notes de bas de page ne sont pas implémentées dans ce format, on ignore {:?}", $($arg)*),
            _ => format!("ODT: footnotes are not yet implemented in this format, ignoring {:?}", $($arg)*),
        }
    });
    ("EPUB ({source}): detected two chapter titles inside the same markdown file, in a file where chapter titles are not even rendered.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("EPUB ({source}): deux titres de chapitre détectés à l'intérieur du même fichier Markdown, dans un fichier où les titres de chapitres ne sont même pas affichés.", $($arg)*),
            _ => format!("EPUB ({source}): detected two chapter titles inside the same markdown file, in a file where chapter titles are not even rendered.", $($arg)*),
        }
    });
    ("Successfully generated LaTeX file: {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier LaTeX généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated LaTeX file: {file}", $($arg)*),
        }
    });
    ("Resources: could not read file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ressources : impossible de lire le fichier {file}", $($arg)*),
            _ => format!("Resources: could not read file {file}", $($arg)*),
        }
    });
    ("EPUB ({source}): detected two chapters inside the same markdown file.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("EPUB ({source}) : deux chapitres détectés à l'intérieur du même fichier Markdown.", $($arg)*),
            _ => format!("EPUB ({source}): detected two chapters inside the same markdown file.", $($arg)*),
        }
    });
    ("Successfully generated HTML directory: {path}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Répertoire HTML généré avec succès : {path}", $($arg)*),
            _ => format!("Successfully generated HTML directory: {path}", $($arg)*),
        }
    });
    ("error reading file {file}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur en lisant le fichier {file} : {error}", $($arg)*),
            _ => format!("error reading file {file}: {error}", $($arg)*),
        }
    });
    ("Inline YAML block could not set {:?} to {:?}: {}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le bloc YAML en ligne n'a pas pu positionner {:?} à {:?} : {}", $($arg)*),
            _ => format!("Inline YAML block could not set {:?} to {:?}: {}", $($arg)*),
        }
    });
    ("'{key}''s path contains invalid UTF-8 code", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le chemin de '{key}' contient de l'UTF-8 invalide", $($arg)*),
            _ => format!("'{key}''s path contains invalid UTF-8 code", $($arg)*),
        }
    });
    ("key '{key}' has been deprecated.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("la clé '{key}' a été dépréciée", $($arg)*),
            _ => format!("key '{key}' has been deprecated.", $($arg)*),
        }
    });
    ("unrecognized key '{key}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("clé '{key}' non reconnue", $($arg)*),
            _ => format!("unrecognized key '{key}'", $($arg)*),
        }
    });
    ("rendering {name}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("dans le rendu de {name} : {error}", $($arg)*),
            _ => format!("rendering {name}: {error}", $($arg)*),
        }
    });
    ("expected a boolean as value for key '{}', found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("un booléen était attendue comme valeur pour la clé '{}', pas {:?}", $($arg)*),
            _ => format!("expected a boolean as value for key '{}', found {:?}", $($arg)*),
        }
    });
    ("in {file}, found footnote definition for note '{reference}' but previous definition already exist, overriding it", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("dans {file}, une définition de note a été trouvée pour '{reference}' mais une définition précédente existait déjà, elle sera remplacée", $($arg)*),
            _ => format!("in {file}, found footnote definition for note '{reference}' but previous definition already exist, overriding it", $($arg)*),
        }
    });
    ("Yaml for {key} in lang {lang} is not a String!", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le Yaml pour {key} dans la langue {lang} n'est pas une chaîne de caractères !", $($arg)*),
            _ => format!("Yaml for {key} in lang {lang} is not a String!", $($arg)*),
        }
    });
    ("invalid template '{template}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("template invalide '{template}'", $($arg)*),
            _ => format!("invalid template '{template}'", $($arg)*),
        }
    });
    ("LaTeX: can't find a tex equivalent for lang '{lang}', fallbacking on english", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("LaTeX: impossible de trouver un équivalent tex pour la langue '{lang}', utilisation de l'anglais par défaut", $($arg)*),
            _ => format!("LaTeX: can't find a tex equivalent for lang '{lang}', fallbacking on english", $($arg)*),
        }
    });
    ("Successfully generated LaTeX file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier LaTeX généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated LaTeX file {file}", $($arg)*),
        }
    });
    ("{:?} is not a string", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{:?} n'est pas une chaîne de caractères", $($arg)*),
            _ => format!("{:?} is not a string", $($arg)*),
        }
    });
    ("could not connect to language tool server: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de se connecter au serveur languagetool : {error}", $($arg)*),
            _ => format!("could not connect to language tool server: {error}", $($arg)*),
        }
    });
    ("EPUB ({source}): conflict between: {title1} and {title2}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("EPUB ({source}) : conflit entre {title1} et {title2}", $($arg)*),
            _ => format!("EPUB ({source}): conflict between: {title1} and {title2}", $($arg)*),
        }
    });
    ("could not write to file {file}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'écrire dans le fichier {file} : {error}", $($arg)*),
            _ => format!("could not write to file {file}: {error}", $($arg)*),
        }
    });
    ("error deleting directory {path}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("erreur dans la suppression du répertoire {path} : {error}", $($arg)*),
            _ => format!("error deleting directory {path}: {error}", $($arg)*),
        }
    });
    ("failed to execute unzip on {file}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'exécuter unzip sur {file} : {error}", $($arg)*),
            _ => format!("failed to execute unzip on {file}: {error}", $($arg)*),
        }
    });
    ("could not send request to server: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'envoyer la requête au serveur : {error}", $($arg)*),
            _ => format!("could not send request to server: {error}", $($arg)*),
        }
    });
    ("Error in setting key {}: {}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur en initialisant la clé {}: {}", $($arg)*),
            _ => format!("Error in setting key {}: {}", $($arg)*),
        }
    });
    ("Successfully generated PDF file: {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier PDF généré avec succès : {file}", $($arg)*),
            _ => format!("Successfully generated PDF file: {file}", $($arg)*),
        }
    });
    ("{path} already exists, deleting it", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{path} existe déjà, il sera supprimé", $($arg)*),
            _ => format!("{path} already exists, deleting it", $($arg)*),
        }
    });
    ("could not create caribon parser: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer l'analyseur caribon : {error}", $($arg)*),
            _ => format!("could not create caribon parser: {error}", $($arg)*),
        }
    });
    ("{:?} is not a path", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{:?} n'est pas un chemin de fichier", $($arg)*),
            _ => format!("{:?} is not a path", $($arg)*),
        }
    });
    ("Resources: could not guess mime type of file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ressources : impossible de deviner le type mime du fichier {file}", $($arg)*),
            _ => format!("Resources: could not guess mime type of file {file}", $($arg)*),
        }
    });
    ("... but it didn't parse correctly as YAML('{error}'), so treating it like Markdown.", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("... mais il n'a pas pu être analysé comme du YAML ('{error}'), on le traite donc comme du Markdown.", $($arg)*),
            _ => format!("... but it didn't parse correctly as YAML('{error}'), so treating it like Markdown.", $($arg)*),
        }
    });
    ("could not create directory in {path}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de créer un répertoire dans {path} : {error}", $($arg)*),
            _ => format!("could not create directory in {path}: {error}", $($arg)*),
        }
    });
    ("error while reading resource file: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("erreur en lisant le fichier ressource : {error}", $($arg)*),
            _ => format!("error while reading resource file: {error}", $($arg)*),
        }
    });
    ("'{value}''s path contains invalid UTF-8 code", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le chemin de '{value}' contient de l'UTF-8 invalide", $($arg)*),
            _ => format!("'{value}''s path contains invalid UTF-8 code", $($arg)*),
        }
    });
    ("expected a string as value for key '{}', found {:?}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("une chaîne de caractères était attendue comme valeur pour la clé '{}', pas {:?}", $($arg)*),
            _ => format!("expected a string as value for key '{}', found {:?}", $($arg)*),
        }
    });
    ("failed to remove file {file}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Impossible de supprimer le fichier '{file}'", $($arg)*),
            _ => format!("failed to remove file {file}", $($arg)*),
        }
    });
    ("'{old_key}' has been deprecated, you should now use '{new_key}'", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("'{old_key}' a été déprécié, vous devriez maintenant utiliser '{new_key}'", $($arg)*),
            _ => format!("'{old_key}' has been deprecated, you should now use '{new_key}'", $($arg)*),
        }
    });
    ("Error connecting to language tool server: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans la connexion au serveur languagetool : {error}", $($arg)*),
            _ => format!("Error connecting to language tool server: {error}", $($arg)*),
        }
    });
    ("error while reading image file {file}: {error}", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("erreur en lisant le fichier image {file} : {error}", $($arg)*),
            _ => format!("error while reading image file {file}: {error}", $($arg)*),
        }
    });
    ("no output pdf file specified '{output}' in book config", $($arg:tt)*) => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("pas de fichier pdf spécifié '{output}' dans la configuration du livre", $($arg)*),
            _ => format!("no output pdf file specified '{output}' in book config", $($arg)*),
        }
    });
    ("Inline YAML block \
                                                                             set {:?} to {:?}", $($arg:tt)*) => (lformat!("Inline YAML block set {:?} to {:?}", $($arg)*));
    ("Resources: book includes non-local image {file}, which might \
                                   cause problem for proper inclusion.", $($arg:tt)*) => (lformat!("Resources: book includes non-local image {file}, which might cause problem for proper inclusion.", $($arg)*));
    ("'{value}''s path contains invalid \
                                                                        UTF-8 code", $($arg:tt)*) => (lformat!("'{value}''s path contains invalid UTF-8 code", $($arg)*));
    ("this version of Crowbook has been compiled \
                                              without support for proofreading, not generating \
                                              {path}", $($arg:tt)*) => (lformat!("this version of Crowbook has been compiled without support for proofreading, not generating {path}", $($arg)*));
    ("expected a boolean as value for key '{}', \
                                                 found {:?}", $($arg:tt)*) => (lformat!("expected a boolean as value for key '{}', found {:?}", $($arg)*));
    ("rendering 'html.footer' \
                                                       template:\n{error}", $($arg:tt)*) => (lformat!("rendering 'html.footer' template:\n{error}", $($arg)*));
    ("Expected a string as value for key {}, found \
                                                 {:?}", $($arg:tt)*) => (lformat!("Expected a string as value for key {}, found {:?}", $($arg)*));
    ("Resources: book includes image {file} which doesn't have \
                                       an extension", $($arg:tt)*) => (lformat!("Resources: book includes image {file} which doesn't have an extension", $($arg)*));
    ("Ill-formatted OPTIONS string: unrecognized type \
                                     '{option_type}'", $($arg:tt)*) => (lformat!("Ill-formatted OPTIONS string: unrecognized type '{option_type}'", $($arg)*));
    ("this version of Crowbook has been compiled \
                                              without support for proofreading, not generating \
                                              LaTeX file {file}", $($arg:tt)*) => (lformat!("this version of Crowbook has been compiled without support for proofreading, not generating LaTeX file {file}", $($arg)*));
    ("Resources: could not find a in-book match for link \
                                        {file}", $($arg:tt)*) => (lformat!("Resources: could not find a in-book match for link {file}", $($arg)*));
    ("error in epub rendering: {path} is \
                                                       neither a file nor a directory", $($arg:tt)*) => (lformat!("error in epub rendering: {path} is neither a file nor a directory", $($arg)*));
    ("- **`{key}`**
    - **type**: {option_type}
    - **default value**: `{default}`
    - {comment}\n", $($arg:tt)*) => (lformat!("- **`{key}`**\n    - **type**: {option_type}\n    - **default value**: `{default}`\n    - {comment}\n", $($arg)*));
    ("ignored annotation {:?} as it wasn't compatible \
                                              with the Markdown structure", $($arg:tt)*) => (lformat!("ignored annotation {:?} as it wasn't compatible with the Markdown structure", $($arg)*));
    ("this version of Crowbook has been compiled \
                                              without support for proofreading,not generating \
                                              HTML file {file}", $($arg:tt)*) => (lformat!("this version of Crowbook has been compiled without support for proofreading,not generating HTML file {file}", $($arg)*));
    ("ODT: footnotes are not yet implemented in this format, \
                                       ignoring {:?}", $($arg:tt)*) => (lformat!("ODT: footnotes are not yet implemented in this format, ignoring {:?}", $($arg)*));
    ("... but it didn't parse correctly as \
                                                         YAML('{error}'), so treating it like \
                                                         Markdown.", $($arg:tt)*) => (lformat!("... but it didn't parse correctly as YAML('{error}'), so treating it like Markdown.", $($arg)*));
    ("{path} already exists and is not a \
                                                       directory", $($arg:tt)*) => (lformat!("{path} already exists and is not a directory", $($arg)*));
    ("LaTeX: can't find a tex equivalent for lang '{lang}', \
                                     fallbacking on english", $($arg:tt)*) => (lformat!("LaTeX: can't find a tex equivalent for lang '{lang}', fallbacking on english", $($arg)*));
    ("EPUB: could not guess the format of {file} based on \
                                     extension. Assuming png.", $($arg:tt)*) => (lformat!("EPUB: could not guess the format of {file} based on extension. Assuming png.", $($arg)*));
    ("No output file specified, and book doesn't specify an \
                                           output file for {}", $($arg:tt)*) => (lformat!("No output file specified, and book doesn't specify an output file for {}", $($arg)*));
    ("Ignoring YAML \
                                                                    block:\n---\n{block}---", $($arg:tt)*) => (lformat!("Ignoring YAML block:\n---\n{block}---", $($arg)*));
    ("Warning: book contains chapter '{file}' in a directory above \
                                   the book file, this might cause problems", $($arg:tt)*) => (lformat!("Warning: book contains chapter '{file}' in a directory above the book file, this might cause problems", $($arg)*));
    ("'{old_key}' has been deprecated, you should \
                                                  now use '{new_key}'", $($arg:tt)*) => (lformat!("'{old_key}' has been deprecated, you should now use '{new_key}'", $($arg)*));
    ("You must pass the file of a book configuration \
                               file.\n\n{}\n\nFor more information try --help.", $($arg:tt)*) => (lformat!("You must pass the file of a book configuration file.\n\n{}\n\nFor more information try --help.", $($arg)*));
    ("footnote reference {reference} does \
                                                           not have a matching definition", $($arg:tt)*) => (lformat!("footnote reference {reference} does not have a matching definition", $($arg)*));
    ("value '{value}' for key '{key}' does not \
                                                 contain one and only one YAML value", $($arg:tt)*) => (lformat!("value '{value}' for key '{key}' does not contain one and only one YAML value", $($arg)*));
    ("file {file} refers to an absolute or a parent \
                                               path.
This is forbidden because we are supposed \
                                               to create a temporary file in a temporary dir.", $($arg:tt)*) => (lformat!("file {file} refers to an absolute or a parent path.\nThis is forbidden because we are supposed to create a temporary file in a temporary dir.", $($arg)*));
    ("this version of Crowbook has been compiled \
                                              without support for proofreading, not generating \
                                              {file}", $($arg:tt)*) => (lformat!("this version of Crowbook has been compiled without support for proofreading, not generating {file}", $($arg)*));
    ("'{key}''s path contains invalid \
                                                            UTF-8 code", $($arg:tt)*) => (lformat!("'{key}''s path contains invalid UTF-8 code", $($arg)*));
    ("Trying to run grammar check on {file}, this might take a \
                                    while...", $($arg:tt)*) => (lformat!("Trying to run grammar check on {file}, this might take a while...", $($arg)*));
    ("EPUB ({source}): detected two chapters inside the same \
                                       markdown file.", $($arg:tt)*) => (lformat!("EPUB ({source}): detected two chapters inside the same markdown file.", $($arg)*));
    ("EPUB ({source}): detected two chapter titles inside the \
                                       same markdown file, in a file where chapter titles are \
                                       not even rendered.", $($arg:tt)*) => (lformat!("EPUB ({source}): detected two chapter titles inside the same markdown file, in a file where chapter titles are not even rendered.", $($arg)*));
    ("Found something that looked like a \
                                                         YAML block:\n{block}", $($arg:tt)*) => (lformat!("Found something that looked like a YAML block:\n{block}", $($arg)*));
    ("Inline YAML block \
                                                                             replaced {:?} \
                                                                             previously set to \
                                                                             {:?} to {:?}", $($arg:tt)*) => (lformat!("Inline YAML block replaced {:?} previously set to {:?} to {:?}", $($arg)*));
    ("Inline YAML block could \
                                                                        not set {:?} to {:?}: {}", $($arg:tt)*) => (lformat!("Inline YAML block could not set {:?} to {:?}: {}", $($arg)*));
    ("can't get '{key}' as a list of files, only \
                                                    valid if key is resources.files", $($arg:tt)*) => (lformat!("can't get '{key}' as a list of files, only valid if key is resources.files", $($arg)*));
    ("in {file}, found footnote definition for \
                                                      note '{reference}' but previous \
                                                      definition already exist, overriding it", $($arg:tt)*) => (lformat!("in {file}, found footnote definition for note '{reference}' but previous definition already exist, overriding it", $($arg)*));
    ("expected an integer as value for key '{}', \
                                                 found {:?}", $($arg:tt)*) => (lformat!("expected an integer as value for key '{}', found {:?}", $($arg)*));
    ("could not render `{key}` for \
                                                           metadata:\n{error}", $($arg:tt)*) => (lformat!("could not render `{key}` for metadata:\n{error}", $($arg)*));
    ("Error initializing book: could not set {key} to {value}: \
                                     {error}", $($arg:tt)*) => (lformat!("Error initializing book: could not set {key} to {value}: {error}", $($arg)*));
    ("could not parse {file} as a book \
                                                       file.\nMaybe you meant to run crowbook \
                                                       with the --single argument?", $($arg:tt)*) => (lformat!("could not parse {file} as a book file.\nMaybe you meant to run crowbook with the --single argument?", $($arg)*));
    ("could not parse '{value}' as a \
                                                            char: does not contain exactly one \
                                                            char", $($arg:tt)*) => (lformat!("could not parse '{value}' as a char: does not contain exactly one char", $($arg)*));
    ("ignored annotation {:?} as it \
                                                              wasn't compatible with the \
                                                              Markdown structure", $($arg:tt)*) => (lformat!("ignored annotation {:?} as it wasn't compatible with the Markdown structure", $($arg)*));
    ("expected a float as value for key '{}', found \
                                                 {:?}", $($arg:tt)*) => (lformat!("expected a float as value for key '{}', found {:?}", $($arg)*));
    ("LaTeX ({source}): image '{url}' doesn't seem to be \
                                         local; ignoring it.", $($arg:tt)*) => (lformat!("LaTeX ({source}): image '{url}' doesn't seem to be local; ignoring it.", $($arg)*));
    ("expected a string as value containing a char \
                                                 for key '{}', found {:?}", $($arg:tt)*) => (lformat!("expected a string as value containing a char for key '{}', found {:?}", $($arg)*));
    ("expected a string as value for key '{}', found \
                                                 {:?}", $($arg:tt)*) => (lformat!("expected a string as value for key '{}', found {:?}", $($arg)*));
    ("could not parse '{value}' as a float \
                                                         for key '{key}'", $($arg:tt)*) => (lformat!("could not parse '{value}' as a float for key '{key}'", $($arg)*));
    ("Path of a stylesheet for EPUB") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'une feuille de style pour le fichier EPUB"),
            _ => format!("Path of a stylesheet for EPUB"),
        }
    });
    ("Additional metadata") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Métadonnées additionnelles"),
            _ => format!("Additional metadata"),
        }
    });
    ("Display only one chapter at a time (with a button to display all)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("N'affiche qu'un seul chapitre à la fois (avec un bouton pour les afficher tous)"),
            _ => format!("Display only one chapter at a time (with a button to display all)"),
        }
    });
    ("Special option") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Option spéciale"),
            _ => format!("Special option"),
        }
    });
    ("Error during temporary files editing: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur durant l'édition de fichiers temporaires :"),
            _ => format!("Error during temporary files editing: "),
        }
    });
    ("Error: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur : "),
            _ => format!("Error: "),
        }
    });
    ("List all possible options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Liste toutes les options possibles"),
            _ => format!("List all possible options"),
        }
    });
    ("Multifile HTML options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options HTML multi-fichiers"),
            _ => format!("Multifile HTML options"),
        }
    });
    ("Custom footer to display at the end of HTML file(s)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Pied de page personnalisé à afficher à la fin des fichiers HTML"),
            _ => format!("Custom footer to display at the end of HTML file(s)"),
        }
    });
    ("Enable fuzzy string matching") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Active la correspondance approximative des chaînes de caractère"),
            _ => format!("Enable fuzzy string matching"),
        }
    });
    ("Import another book configuration file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Importe un autre fichier de configuration de livre"),
            _ => format!("Import another book configuration file"),
        }
    });
    ("Attempting to generate HTML for proofreading...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le HTML pour la relecture..."),
            _ => format!("Attempting to generate HTML for proofreading..."),
        }
    });
    ("empty str token, could not find initial") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("jeton str vide, impossible de trouver la lettrine"),
            _ => format!("empty str token, could not find initial"),
        }
    });
    ("Provides syntax highlighting for code blocks (using highlight.js)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Active la coloration syntaxique pour les blocs de code (en utilisant highlight.js)"),
            _ => format!("Provides syntax highlighting for code blocks (using highlight.js)"),
        }
    });
    ("image") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("image"),
            _ => format!("image"),
        }
    });
    ("Path of a stylesheet for HTML rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'une feuille de style pour le rendu HTML"),
            _ => format!("Path of a stylesheet for HTML rendering"),
        }
    });
    ("Attempting to generate PDF for proofreading...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le PDF pour la relecture..."),
            _ => format!("Attempting to generate PDF for proofreading..."),
        }
    });
    ("Display a table of content in the document") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche une table des matières dans le document"),
            _ => format!("Display a table of content in the document"),
        }
    });
    ("Path of an HTML template") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'un template HTML"),
            _ => format!("Path of an HTML template"),
        }
    });
    ("Enable proofreading") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Activer la génération de versions pour la relecture"),
            _ => format!("Enable proofreading"),
        }
    });
    ("Set base path but only for templates files. Useless if resources.base_path is set.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Règle le chemin de base mais seulement pour les fichiers templates. Inutile si resources.base_path est réglé."),
            _ => format!("Set base path but only for templates files. Useless if resources.base_path is set."),
        }
    });
    ("Error during rendering: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans le rendu : "),
            _ => format!("Error during rendering: "),
        }
    });
    ("Attempting to generate epub...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer l'EPUB..."),
            _ => format!("Attempting to generate epub..."),
        }
    });
    ("found invalid chapter definition in the chapter list") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("définition de chapitre invalide trouvée dans la liste des chapitres"),
            _ => format!("found invalid chapter definition in the chapter list"),
        }
    });
    ("Command to use to zip files (for EPUB/ODT)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Commande à lancer pour zipper des fichiers (pour EPUB/ODT)"),
            _ => format!("Command to use to zip files (for EPUB/ODT)"),
        }
    });
    ("Set another highlight.js version than the bundled one") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Donne une autre version de highlight.js que celle qui est embarquée"),
            _ => format!("Set another highlight.js version than the bundled one"),
        }
    });
    ("HTML options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options HTML"),
            _ => format!("HTML options"),
        }
    });
    ("Paths where additional resources should be copied in the EPUB file or HTML directory ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemins où les ressources additionnelles devraient être copiées dans le fichier EPUB ou dans le répertoire HTML"),
            _ => format!("Paths where additional resources should be copied in the EPUB file or HTML directory "),
        }
    });
    ("A list of additional files is only valid with the --create option.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Une liste de fichiers additionnels n'est valide qu'avec l'option --create."),
            _ => format!("A list of additional files is only valid with the --create option."),
        }
    });
    ("Replace unicode non breaking spaces with HTML entities and CSS") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Remplace les espaces insécables unicode par des entités HTML et du CSS"),
            _ => format!("Replace unicode non breaking spaces with HTML entities and CSS"),
        }
    });
    ("Enable inline YAML blocks to override options set in config file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Permet aux blocs YAML en ligne de rédéfinir des options déjà définies par le fichier de configuration"),
            _ => format!("Enable inline YAML blocks to override options set in config file"),
        }
    });
    ("Path of index.html template") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin du template index.html"),
            _ => format!("Path of index.html template"),
        }
    });
    ("Error converting BookOption: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur en convertissant BookOption :"),
            _ => format!("Error converting BookOption: "),
        }
    });
    ("could not compile template for nav.xhtml") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template pour nav.xhtml"),
            _ => format!("could not compile template for nav.xhtml"),
        }
    });
    ("Attempting to generate html directory...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le répertoire HTML..."),
            _ => format!("Attempting to generate html directory..."),
        }
    });
    ("could not compile template for cover.xhtml") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template pour cover.xhtml"),
            _ => format!("could not compile template for cover.xhtml"),
        }
    });
    ("Parts are not supported yet") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Les parties ne sont pas encore supportées"),
            _ => format!("Parts are not supported yet"),
        }
    });
    ("Max threshold of differences to consider two strings a repetition") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Seuil maximal de différence pour considérer deux mots comme une répétition"),
            _ => format!("Max threshold of differences to consider two strings a repetition"),
        }
    });
    ("Standalone HTML options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options pour le HTML autonome"),
            _ => format!("Standalone HTML options"),
        }
    });
    ("Print version information") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche le numéro de version"),
            _ => format!("Print version information"),
        }
    });
    ("no output epub file specified in book config") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("pas de fichier EPUB de sortie spécifié dans la configuration du livre"),
            _ => format!("no output epub file specified in book config"),
        }
    });
    ("could not compile template 'rendering.inline_toc'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'rendering.inline_toc'"),
            _ => format!("could not compile template 'rendering.inline_toc'"),
        }
    });
    ("ODT: blockquotes and codeblocks are not currently implemented for ODT") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("ODT: les blocs de citation et de code ne sont pas encore implémentés pour ODT"),
            _ => format!("ODT: blockquotes and codeblocks are not currently implemented for ODT"),
        }
    });
    ("Naming scheme of chapters") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Schéma de nommage des chapitres"),
            _ => format!("Naming scheme of chapters"),
        }
    });
    ("Path to the cover of the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin de la couverture du livre"),
            _ => format!("Path to the cover of the book"),
        }
    });
    ("Attempting to generate pdf...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le PDF..."),
            _ => format!("Attempting to generate pdf..."),
        }
    });
    ("Path of a javascript file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'un fichier javascript"),
            _ => format!("Path of a javascript file"),
        }
    });
    ("could not compile template 'html_dir.chapter.html") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'html_dir.chapter.html"),
            _ => format!("could not compile template 'html_dir.chapter.html"),
        }
    });
    ("Output directory name for HTML rendering with proofread features") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom d'un répertoire où générer le HTML pour la relecture"),
            _ => format!("Output directory name for HTML rendering with proofread features"),
        }
    });
    ("image or cover") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("image ou couverture"),
            _ => format!("image or cover"),
        }
    });
    ("Subject of the book (used for EPUB metadata") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Sujet du livre (utilisé pour les métadonnées EPUB)"),
            _ => format!("Subject of the book (used for EPUB metadata"),
        }
    });
    ("The  maximum heading levels that should be numbered (0: no numbering, 1: only chapters, ..., 6: all)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Le nombre maximum de niveaux qui devraient être numérotés (0 : aucune numérotation, 1 : seulement les chapitres, ..., 6 : tout)"),
            _ => format!("The  maximum heading levels that should be numbered (0: no numbering, 1: only chapters, ..., 6: all)"),
        }
    });
    ("Proofreading options (only for output.proofread.* targets)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options de relecture (seulement pour les cibles output.proofread.*)"),
            _ => format!("Proofreading options (only for output.proofread.* targets)"),
        }
    });
    ("Error accessing book option: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur en accèdant à l'option : "),
            _ => format!("Error accessing book option: "),
        }
    });
    ("generated HTML for cover.xhtml was not utf-8 valid") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le HTML généré pour cover.xhtml contient de l'UTF-8 invalide"),
            _ => format!("generated HTML for cover.xhtml was not utf-8 valid"),
        }
    });
    ("metadata") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("métadonnée"),
            _ => format!("metadata"),
        }
    });
    ("Output options (for proofreading)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options de sortie (pour la relecture)"),
            _ => format!("Output options (for proofreading)"),
        }
    });
    ("integer") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("entier"),
            _ => format!("integer"),
        }
    });
    ("Print warnings in parsing/rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche les avertissements dans l'analyse et le rendu"),
            _ => format!("Print warnings in parsing/rendering"),
        }
    });
    ("An odd number of arguments was passed to --set, but it takes a list of key value pairs.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Un nombre impair d'arguments a été donné à --set, alors qu'il prend une liste de paires clé-valeur."),
            _ => format!("An odd number of arguments was passed to --set, but it takes a list of key value pairs."),
        }
    });
    ("ODT: images not currently implemented for this format") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("ODT: les images ne sont pas encore implémentées pour ce format"),
            _ => format!("ODT: images not currently implemented for this format"),
        }
    });
    ("header generated by mustache was not valid utf-8") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("l'en-tête générée par mustache contenait de l'UTF-8 invalide"),
            _ => format!("header generated by mustache was not valid utf-8"),
        }
    });
    ("DEPRECATED") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("DÉPRÉCIÉ"),
            _ => format!("DEPRECATED"),
        }
    });
    ("Attempting to generate LaTeX...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le LaTeX..."),
            _ => format!("Attempting to generate LaTeX..."),
        }
    });
    ("Output directory name for HTML rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom de répertoire où générer le HTML"),
            _ => format!("Output directory name for HTML rendering"),
        }
    });
    ("Metadata") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Métadonnée"),
            _ => format!("Metadata"),
        }
    });
    ("file contains invalid UTF-8, could not parse it") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier contient de l'UTF-8 invalide, impossible de l'analyser"),
            _ => format!("file contains invalid UTF-8, could not parse it"),
        }
    });
    ("markdown file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("fichier Markdown"),
            _ => format!("markdown file"),
        }
    });
    ("Attempting to generate html directory for proofreading...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le répertoire HTML pour la relecture..."),
            _ => format!("Attempting to generate html directory for proofreading..."),
        }
    });
    ("Path of a chapter.html template") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'un template chapter.html"),
            _ => format!("Path of a chapter.html template"),
        }
    });
    ("EPUB version to generate (2 or 3)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Version du format EPUB à générér (2 ou 3)"),
            _ => format!("EPUB version to generate (2 or 3)"),
        }
    });
    ("Port to connect to languagetool-server") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Port sur lequel se connecter à languagetool-server"),
            _ => format!("Port to connect to languagetool-server"),
        }
    });
    ("Render a Markdown book in EPUB, PDF or HTML.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fait le rendu en EPUB, PDF ou HTML d'un livre écrit en Markdown."),
            _ => format!("Render a Markdown book in EPUB, PDF or HTML."),
        }
    });
    ("Use initials ('lettrines') for first letter of a chapter (experimental)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Utilise des lettrines pour la première lettre de chaque chapitre (expérimental)"),
            _ => format!("Use initials ('lettrines') for first letter of a chapter (experimental)"),
        }
    });
    ("boolean") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("booléen"),
            _ => format!("boolean"),
        }
    });
    ("Info: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Info : "),
            _ => format!("Info: "),
        }
    });
    ("Version of the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Version du livre"),
            _ => format!("Version of the book"),
        }
    });
    ("If enabled, tries to replace vertical quotations marks to curly ones.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Si activé, essaie de remplacer les apostrophes et guillemets droits par des apostrophes et guillemets typographiques"),
            _ => format!("If enabled, tries to replace vertical quotations marks to curly ones."),
        }
    });
    ("Print help information") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche l'aide"),
            _ => format!("Print help information"),
        }
    });
    ("Warning: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Avertissement : "),
            _ => format!("Warning: "),
        }
    });
    ("Crowbook options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options Crowbook"),
            _ => format!("Crowbook options"),
        }
    });
    ("could not render template for toc.ncx") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template pour toc.ncx"),
            _ => format!("could not render template for toc.ncx"),
        }
    });
    ("book chapter") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("chapitre de livre"),
            _ => format!("book chapter"),
        }
    });
    ("generated HTML was not utf-8 valid") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le HTML contient de l'UTF-8 invalide"),
            _ => format!("generated HTML was not utf-8 valid"),
        }
    });
    ("Input options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options d'entrée"),
            _ => format!("Input options"),
        }
    });
    ("Custom header to display at the beginning of html file(s)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("En-tête personnalisée à afficher au début de chaque fichier HTML"),
            _ => format!("Custom header to display at the beginning of html file(s)"),
        }
    });
    ("Path of an xhtml template for each chapter") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'um template XHTML pour chaque chapitre"),
            _ => format!("Path of an xhtml template for each chapter"),
        }
    });
    ("could not compile template for content.opf") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template pour content.opf"),
            _ => format!("could not compile template for content.opf"),
        }
    });
    ("Set a list of book options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Règle une liste d'options pour le livre"),
            _ => format!("Set a list of book options"),
        }
    });
    ("Highlight non breaking spaces so it is easier to see if typography is correct") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Surligne les espaces insécables pour qu'il soit plus facile de vérifier que la typographie est correcte"),
            _ => format!("Highlight non breaking spaces so it is easier to see if typography is correct"),
        }
    });
    ("If set to true, use Caribon to detect repetitions") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Si mis à vrai, utilise Caribon pour détecter les répétitions"),
            _ => format!("If set to true, use Caribon to detect repetitions"),
        }
    });
    ("ill-formatted line specifying chapter number") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("line spécifiant un numéro de chapitre mal formattée"),
            _ => format!("ill-formatted line specifying chapter number"),
        }
    });
    ("Resources option") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options de ressources"),
            _ => format!("Resources option"),
        }
    });
    ("could not compile template 'html_single.html'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'html_single.html'"),
            _ => format!("could not compile template 'html_single.html'"),
        }
    });
    ("Removed") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Supprimé"),
            _ => format!("Removed"),
        }
    });
    ("Output file name for ODT rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom de fichier pour la génération du format ODT"),
            _ => format!("Output file name for ODT rendering"),
        }
    });
    ("ODT: tables are not currently implemented for this format") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("ODT: les tableaux ne sont pas encore implémentés pour ce format"),
            _ => format!("ODT: tables are not currently implemented for this format"),
        }
    });
    ("Why is this method called if cover is None???") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Pourquoi cette méthode est-elle appelée si la couverture est None???"),
            _ => format!("Why is this method called if cover is None???"),
        }
    });
    ("could not compile template 'html.css") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'html.css'"),
            _ => format!("could not compile template 'html.css"),
        }
    });
    ("Output options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options de sortie"),
            _ => format!("Output options"),
        }
    });
    ("File containing the book configuration file, or a Markdown file when called with --single") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier contenant la configuration du livre, ou un fichier Markdown avec l'argument --single"),
            _ => format!("File containing the book configuration file, or a Markdown file when called with --single"),
        }
    });
    ("path") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("chemin"),
            _ => format!("path"),
        }
    });
    ("Generate specific format") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Génère un format spécifique"),
            _ => format!("Generate specific format"),
        }
    });
    ("Successfully generated LaTeX") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("LaTeX généré avec succès"),
            _ => format!("Successfully generated LaTeX"),
        }
    });
    ("LaTeX options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options LaTeX"),
            _ => format!("LaTeX options"),
        }
    });
    ("could not compile template 'html_single.js'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler te template 'html_single.js'"),
            _ => format!("could not compile template 'html_single.js'"),
        }
    });
    ("generated content.xml was not utf-8 valid") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier content.xml généré contenait de l'UTF-8 invalide"),
            _ => format!("generated content.xml was not utf-8 valid"),
        }
    });
    ("Set another highlight.js CSS theme than the default one") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Donne un autre thème CSS highlight.js à utilise que celui par défaut"),
            _ => format!("Set another highlight.js CSS theme than the default one"),
        }
    });
    ("Path where to find resources (in the source tree). By default, links and images are relative to the Markdown file. If this is set, it will be to this path.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin où trouver les ressources. Par défaut, les liens et les images sont relatifs au fichier Markdown. Avec cette option, ce sera relatif à ce chemin."),
            _ => format!("Path where to find resources (in the source tree). By default, links and images are relative to the Markdown file. If this is set, it will be to this path."),
        }
    });
    ("LaTeX command to use for generating PDF") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Commande LaTeX utilisée pour générer le PDF"),
            _ => format!("LaTeX command to use for generating PDF"),
        }
    });
    ("book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("livre"),
            _ => format!("book"),
        }
    });
    ("Max distance between two occurences so it is considered a repetition") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Distance maximale entre deux occurrences d'un mot pour considérer qu'il s'agit d'une répétition"),
            _ => format!("Max distance between two occurences so it is considered a repetition"),
        }
    });
    ("Attempting to generate ODT...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer l'ODT..."),
            _ => format!("Attempting to generate ODT..."),
        }
    });
    ("Prints the default content of a template") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche le contenu par défaut d'un template"),
            _ => format!("Prints the default content of a template"),
        }
    });
    ("Output of latex command:") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Sortie de la commande latex : "),
            _ => format!("Output of latex command:"),
        }
    });
    ("Set base path but only for additional files. Useless if resources.base_path is set.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Donne un chemin de base mais seulement pour les fichiers additionnels. Inutile si resources.base_path est déjà réglé."),
            _ => format!("Set base path but only for additional files. Useless if resources.base_path is set."),
        }
    });
    ("Don't print info/error messages") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("N'affiche pas les messages d'erreurs ou d'information"),
            _ => format!("Don't print info/error messages"),
        }
    });
    ("odt.render_book called while book.output_odt is not set") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("odt.render_book appelée alors que book.output.odt n'est pas initialisé"),
            _ => format!("odt.render_book called while book.output_odt is not set"),
        }
    });
    ("Title of the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Titre du livre"),
            _ => format!("Title of the book"),
        }
    });
    ("Threshold to detect a repetition") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Seuil pour détecter une répétition"),
            _ => format!("Threshold to detect a repetition"),
        }
    });
    ("could not compile template for title page") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template pour la page de titre"),
            _ => format!("could not compile template for title page"),
        }
    });
    ("Name of the table of contents if it is displayed in document") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom de la table des matières si elle est affichée dans le document"),
            _ => format!("Name of the table of contents if it is displayed in document"),
        }
    });
    ("could not compile template 'epub.css'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'epub.css'"),
            _ => format!("could not compile template 'epub.css'"),
        }
    });
    ("Output file name for HTML rendering with proofread features") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ficher de sortie où générer le HTML avec options de relecture"),
            _ => format!("Output file name for HTML rendering with proofread features"),
        }
    });
    ("generated HTML in content.opf was not valid utf-8") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier content.opf généré contenait de l'UTF-8 invalide"),
            _ => format!("generated HTML in content.opf was not valid utf-8"),
        }
    });
    ("List all possible options, formatted in Markdown") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Liste toutes les options possibles, formatées en Markdown"),
            _ => format!("List all possible options, formatted in Markdown"),
        }
    });
    ("Output file name for PDF rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom de fichier pour le PDF à générer"),
            _ => format!("Output file name for PDF rendering"),
        }
    });
    ("string") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("chaîne de caractères"),
            _ => format!("string"),
        }
    });
    ("YAML part of the book is not a valid hashmap") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("La partie YAML du livre n'est pas une hashmap valide"),
            _ => format!("YAML part of the book is not a valid hashmap"),
        }
    });
    ("If set to false, will disactivate proofreading even if one of output.proofread.x is present") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Si mis à faux, désactivera la génération de fichiers de relecture même si une des cibles output.proofread.x est présente"),
            _ => format!("If set to false, will disactivate proofreading even if one of output.proofread.x is present"),
        }
    });
    ("Successfully generated HTML") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("HTML généré avec succès"),
            _ => format!("Successfully generated HTML"),
        }
    });
    ("Deprecated options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options dépréciées"),
            _ => format!("Deprecated options"),
        }
    });
    ("char") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("caractère"),
            _ => format!("char"),
        }
    });
    ("ODT: ordered list not currently implemented for this format, fallbacking to unordered one") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("ODT: les listes ordonnées ne sont pas encore implémentées pour ce format, utilisation d'une liste non ordonnée à la place."),
            _ => format!("ODT: ordered list not currently implemented for this format, fallbacking to unordered one"),
        }
    });
    ("Path of a LaTeX template file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'un fichier template LaTeX"),
            _ => format!("Path of a LaTeX template file"),
        }
    });
    ("Description of the book (used for EPUB metadata") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Description du livre (utilisé pour les métadonnées EPUB)"),
            _ => format!("Description of the book (used for EPUB metadata"),
        }
    });
    ("chapter filenames must not contain whitespace") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("les noms de fichier des chapitres ne doivent pas contenir d'espace"),
            _ => format!("chapter filenames must not contain whitespace"),
        }
    });
    ("Ignore proper nouns for repetitions") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ignore les noms propres pour les répétitions"),
            _ => format!("Ignore proper nouns for repetitions"),
        }
    });
    ("float") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("flottant"),
            _ => format!("float"),
        }
    });
    ("Output file name for LaTeX rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fichier du format LaTeX à générer"),
            _ => format!("Output file name for LaTeX rendering"),
        }
    });
    ("could not compile template") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template"),
            _ => format!("could not compile template"),
        }
    });
    ("no chapter name specified") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("pas de nom de chapitre spécifié"),
            _ => format!("no chapter name specified"),
        }
    });
    ("Date the book was revised") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Date de dernière révision du livre"),
            _ => format!("Date the book was revised"),
        }
    });
    ("template path") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("chemin d'un template"),
            _ => format!("template path"),
        }
    });
    ("License of the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Licence du livre"),
            _ => format!("License of the book"),
        }
    });
    ("If true, try to use language tool server to grammar check the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Si mis à vrai, essaie d'utiliser le serveur languagetool pour effectuer une correction grammaticale du livre"),
            _ => format!("If true, try to use language tool server to grammar check the book"),
        }
    });
    ("Output file name for HTML rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom de fichier pour le rendu HTML"),
            _ => format!("Output file name for HTML rendering"),
        }
    });
    ("could not compile template 'html_dir.index.html") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'html_dir.index.html'"),
            _ => format!("could not compile template 'html_dir.index.html"),
        }
    });
    ("Set base path but only for images. Useless if resources.base_path is set.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Donne un chemin de base mais seulement pour les images. Inutile si resources.base_path est réglé."),
            _ => format!("Set base path but only for images. Useless if resources.base_path is set."),
        }
    });
    ("Path of a stylesheet for the colours for HTML") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'une feuille de style pour les couleurs pour le HTML"),
            _ => format!("Path of a stylesheet for the colours for HTML"),
        }
    });
    ("additional resource from resources.files") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("ressource additionnelle de resources.files"),
            _ => format!("additional resource from resources.files"),
        }
    });
    ("Error parsing configuration file: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur dans l'analyse du fichier de configuration : "),
            _ => format!("Error parsing configuration file: "),
        }
    });
    ("Path where to create a temporary directory (default: uses result from Rust's std::env::temp_dir())") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin où créer un répertoire temporaire (par défaut, utilise le résultat de la fonction Rust std::env::temp_dir())"),
            _ => format!("Path where to create a temporary directory (default: uses result from Rust's std::env::temp_dir())"),
        }
    });
    ("Add foontotes to URL of links so they are readable when printed") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Ajoute des notes de bas de page à l'URL des liens pour qu'elle soit lisible à l'impression"),
            _ => format!("Add foontotes to URL of links so they are readable when printed"),
        }
    });
    ("Output file name for PDF rendering with proofread features") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom de fichier pour le PDF à générer avec options de relecture"),
            _ => format!("Output file name for PDF rendering with proofread features"),
        }
    });
    ("generated HTML in toc.ncx was not valid utf-8") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le HTML généré pour toc.ncx contient de l'UTF-8 invalide"),
            _ => format!("generated HTML in toc.ncx was not valid utf-8"),
        }
    });
    ("generated LaTeX was not valid utf-8") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le fichier LaTeX généré contenait de l'UTF-8 invalide"),
            _ => format!("generated LaTeX was not valid utf-8"),
        }
    });
    ("could not compile template 'epub.chapter.xhtml'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'epub.chapter.xhtml'"),
            _ => format!("could not compile template 'epub.chapter.xhtml'"),
        }
    });
    ("{{bin}} {{version}} by {{author}}\n{{about}}\n\nUSAGE:\n    {{usage}}\n\nFLAGS:\n{{flags}}\n\nOPTIONS:\n{{options}}\n\nARGS:\n{{positionals}}\n") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("{{bin}} {{version}} par {{author}}\n{{about}}\n\nUTILISATION:\n    {{usage}}\n\nPARAMÈTRES:\n{{flags}}\n\nOPTIONS:\n{{options}}\n\nARGUMENTS:\n{{positionals}}\n"),
            _ => format!("{{bin}} {{version}} by {{author}}\n{{about}}\n\nUSAGE:\n    {{usage}}\n\nFLAGS:\n{{flags}}\n\nOPTIONS:\n{{options}}\n\nARGS:\n{{positionals}}\n"),
        }
    });
    ("Debug: ") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Debug : "),
            _ => format!("Debug: "),
        }
    });
    ("Language of the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Langue du livre"),
            _ => format!("Language of the book"),
        }
    });
    ("LaTeX class to use") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Classe LaTeX à utiliser"),
            _ => format!("LaTeX class to use"),
        }
    });
    ("not set") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("non défini"),
            _ => format!("not set"),
        }
    });
    ("Rendering options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options de rendu"),
            _ => format!("Rendering options"),
        }
    });
    ("EPUB options") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Options EPUB"),
            _ => format!("EPUB options"),
        }
    });
    ("default:") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("défaut :"),
            _ => format!("default:"),
        }
    });
    ("Set base path but only for links. Useless if resources.base_path is set.") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Donne un chemin de base mais seulement pour les liens. Inutile si resources.base_path est réglé."),
            _ => format!("Set base path but only for links. Useless if resources.base_path is set."),
        }
    });
    ("server didn't respond with a OK status code") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le serveur n'a pas répondu avec un code de statut OK"),
            _ => format!("server didn't respond with a OK status code"),
        }
    });
    ("Error:") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Erreur :"),
            _ => format!("Error:"),
        }
    });
    ("Display footnotes as side notes in HTML/Epub (experimental)") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche les notes de bas de pages sur le côté pour le HTML/EPUB (expérimental)"),
            _ => format!("Display footnotes as side notes in HTML/Epub (experimental)"),
        }
    });
    ("Make Crowbook display more messages") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Fait afficher plus de messages à Crowbook"),
            _ => format!("Make Crowbook display more messages"),
        }
    });
    ("Specify output file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Spécifie un fichier de sortie"),
            _ => format!("Specify output file"),
        }
    });
    ("could not compile template 'html.css'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'html.css'"),
            _ => format!("could not compile template 'html.css'"),
        }
    });
    ("could not compile template 'tex.template'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'tex.template'"),
            _ => format!("could not compile template 'tex.template'"),
        }
    });
    ("Print debugging information") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Affiche des informations de débuggage"),
            _ => format!("Print debugging information"),
        }
    });
    ("Attempting to generate HTML...") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Tentative de générer le HTML..."),
            _ => format!("Attempting to generate HTML..."),
        }
    });
    ("Output of zip command:") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Sortie de la commande zip : "),
            _ => format!("Output of zip command:"),
        }
    });
    ("Path of a media print stylesheet for HTML rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Chemin d'une feuille de style pour l'impression, pour le rendu HTML"),
            _ => format!("Path of a media print stylesheet for HTML rendering"),
        }
    });
    ("error parsing chapter number") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("erreur dans l'analyse du numéro de chapitre"),
            _ => format!("error parsing chapter number"),
        }
    });
    ("Directory where those output files will we written") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Répertoire où ces fichiers de sortie seront écrits"),
            _ => format!("Directory where those output files will we written"),
        }
    });
    ("generated HTML in nav.xhtml was not utf-8 valid") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("le HTML généré pour nav.xhtml contient de l'UTF-8 invalide"),
            _ => format!("generated HTML in nav.xhtml was not utf-8 valid"),
        }
    });
    ("could not get current directory!!!") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible d'obtenir le répertoire courant !!!"),
            _ => format!("could not get current directory!!!"),
        }
    });
    ("Output file name for EPUB rendering") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Nom du fichier EPUB à générer"),
            _ => format!("Output file name for EPUB rendering"),
        }
    });
    ("could not compile template 'rendering.chapter_template'") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("impossible de compiler le template 'rendering.chapter_template'"),
            _ => format!("could not compile template 'rendering.chapter_template'"),
        }
    });
    ("cover") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("couverture"),
            _ => format!("cover"),
        }
    });
    ("Create a new book with existing Markdown files") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Crée un nouveau livre à partir de fichiers Markdown existants"),
            _ => format!("Create a new book with existing Markdown files"),
        }
    });
    ("Renamed") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Renommé"),
            _ => format!("Renamed"),
        }
    });
    ("Toggle cleaning of input markdown according to lang") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Active le nettoyage du Markdown en entrée en fonction de la langue"),
            _ => format!("Toggle cleaning of input markdown according to lang"),
        }
    });
    ("Whitespace-separated list of files to embed in e.g. EPUB file; useful for including e.g. fonts") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Liste de fichiers, séparés par des espaces, à embarquer par exemple dans un fichier EPUB ; utile pour inclure des fontes."),
            _ => format!("Whitespace-separated list of files to embed in e.g. EPUB file; useful for including e.g. fonts"),
        }
    });
    ("Use a single Markdown file instead of a book configuration file") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Utilise un simple fichier Markdown au lieu d'un fichier de configuration de livre"),
            _ => format!("Use a single Markdown file instead of a book configuration file"),
        }
    });
    ("Author of the book") => ({
        let __guard = $crate::localize_macros::__get_lang();
        match __guard.as_str() {
            "fr" => format!("Auteur ou autrice du livre"),
            _ => format!("Author of the book"),
        }
    });
    ("could not compile template \
                                           'rendering.chapter_template'") => (lformat!("could not compile template 'rendering.chapter_template'"));
    ("ODT: ordered list not currently implemented for this \
                                       format, fallbacking to unordered one") => (lformat!("ODT: ordered list not currently implemented for this format, fallbacking to unordered one"));
    ("\
{{bin}} {{version}} by {{author}}
{{about}}

USAGE:
    {{usage}}

FLAGS:
{{flags}}

OPTIONS:
{{options}}

ARGS:
{{positionals}}
") => (lformat!("{{bin}} {{version}} by {{author}}\n{{about}}\n\nUSAGE:\n    {{usage}}\n\nFLAGS:\n{{flags}}\n\nOPTIONS:\n{{options}}\n\nARGS:\n{{positionals}}\n"));
    ("empty str token, could not find \
                                                           initial") => (lformat!("empty str token, could not find initial"));
    ("YAML part of the book is not a \
                                                              valid hashmap") => (lformat!("YAML part of the book is not a valid hashmap"));
    ("could not compile template \
                                                  'rendering.inline_toc'") => (lformat!("could not compile template 'rendering.inline_toc'"));
    ("ODT: blockquotes and codeblocks are not currently \
                                       implemented for ODT") => (lformat!("ODT: blockquotes and codeblocks are not currently implemented for ODT"));
    ("found invalid chapter definition in \
                                                          the chapter list") => (lformat!("found invalid chapter definition in the chapter list"));
    ("server didn't respond with a OK status \
                                                      code") => (lformat!("server didn't respond with a OK status code"));
    ("A list of additional files is only valid with the --create \
                               option.") => (lformat!("A list of additional files is only valid with the --create option."));
    ("An odd number of arguments was passed to --set, but it takes \
                                   a list of key value pairs.") => (lformat!("An odd number of arguments was passed to --set, but it takes a list of key value pairs."));
    ("chapter filenames must not contain \
                                                          whitespace") => (lformat!("chapter filenames must not contain whitespace"));
    ("ill-formatted line specifying \
                                                              chapter number") => (lformat!("ill-formatted line specifying chapter number"));
    ("could not compile template for \
                                                      cover.xhtml") => (lformat!("could not compile template for cover.xhtml"));
    ($($arg:tt)*) => (format!($($arg)*));
}