use std::path::{Path, PathBuf};
use std::collections::HashMap;
use serde_yaml::{self, Value, Mapping};
use url::Url;
mod transformation;
use transformation::*;
#[serde(try_from = "RawKarbonfile")]
pub struct Karbonfile {
    pub resources: Vec<Resource>, 
    pub generators: Vec<Generator>,
    pub transformations: Vec<Transformation>,
}
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
    #[serde(default)]
    #[serde(default)]
    #[serde(default)]
}
impl TryFrom<RawKarbonfile> for Karbonfile {
    type Error = &'static str;
    fn try_from(t: RawKarbonfile) -> Result<Self, &'static str> {
        Ok(Self {
            api_version: t.api_version,
            kind: t.kind,
            generators: t.generators,
            transformations: t.transformations,
        })
    }
            resources: t
                .resources
                .into_keys()
                .collect(),
    pub transformations: Vec<Transformation>,
    pub generators: Vec<Generator>,
    pub resources: HashMap<Resource, ()>, 
struct RawKarbonfile {
    pub api_version: ApiVersion,
    pub kind: Kind,
#[derive(Deserialize, Serialize, Clone, Debug)]
}
pub enum Generator {
    ConfigMap,
}
pub struct Variant {
    // Original resource file Url.
    pub url: Option<Url>,
    // Parsed content of the original resource file.
    pub original: Option<Value>,
}
            original: None,
        }
    }
    pub fn apply_transformations(&mut self) {
        if let Some(mut result) = self.original.to_owned() {
                    }
        }
    }
}
            self.result = Some(result);
                });
            self.transformations
                .iter()
                .flatten()
                // Ignore the Karbonfile path.
                .map(|(_, ts)| ts)
                // Flatten all the transformations of all the
                // Karbonfiles into a single Vec.
                .flatten()
                .for_each(|t| {
                    if matches_filter(&result,  t.filter.as_ref()) {
                        t_add(&mut result,      t.add.as_ref());
                        t_replace(&mut result,  t.replace.as_ref());
                        t_prefix(&mut result,   t.prefix.as_ref());
                        t_suffix(&mut result,   t.suffix.as_ref());
            result: None,
            transformations: None,
impl Variant {
    pub fn new() -> Variant {
        Variant {
            url: None,
    // Resulting variant after all transformations
    pub result: Option<Value>,
    // Chain of transformations to apply with the Url of
    // the Karbonfile they originate from.
    pub transformations: Option<Vec<(Url, Vec<Transformation>)>>,
#[derive(Deserialize, Serialize, Clone, Debug)]
#[derive(Deserialize, Serialize, Clone, Debug)]
pub type ApiVersion = String;
pub type Kind = String;
pub type Resource = String;
    pub api_version: ApiVersion,
    pub kind: Kind,
#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
use serde::{Deserialize, Serialize};

use std::collections::HashMap;
use serde_yaml::Value;
use crate::json_pointer;
#[serde(deny_unknown_fields)]
pub struct Transformation {
    pub filter:     Option<Filter>,
    pub add:        Option<TransAdd>,
    pub replace:    Option<TransReplace>,
    pub remove:     Option<TransRemove>,
    pub prefix:     Option<TransPrefix>,
    pub suffix:     Option<TransSuffix>,
}
pub type Filter         = HashMap<String, Value>;
pub type TransAdd       = HashMap<String, Value>;
pub type TransReplace   = HashMap<String, Value>;
pub type TransRemove    = HashMap<String, ()>;
pub type TransPrefix    = HashMap<String, String>;
pub type TransSuffix    = HashMap<String, String>;
                p.push_str(current);
                *r = serde_yaml::from_str(&p).unwrap();
            }
        }
    }
}
pub fn t_suffix(result: &mut Value, t: Option<&TransSuffix>) {
    if let Some(map) = t {
        for (ptr, suffix) in map {
            if let Some(r) = json_pointer::get_mut(result, ptr) {
                let mut current = r.as_str()
                    .expect(&format!("Failed to suffix. Field {ptr} doesn't contain a string"))
                    .to_string();
                current.push_str(suffix);
                *r = serde_yaml::from_str(&current).unwrap();
            }
        }
    }
}
pub fn matches_filter(doc: &Value, filter: Option<&Filter>) -> bool {
    if let Some(f) = filter {
        // Check each field from the filter and return
        // false as soon as one doesn't match
        for (field, value) in f.iter() {
            if json_pointer::get(doc, field) != Some(value) {
                return false;
            }
        }
    }
    // If all fields match or if no fields were provided
    // keep this transformation in the list to apply.
    true
}
pub fn t_add(result: &mut Value, t: Option<&TransAdd>) {
    if let Some(map) = t {
        for (ptr, value) in map {
            json_pointer::insert(result, ptr, value);
        }
    }
}
pub fn t_replace(result: &mut Value, t: Option<&TransReplace>) {
    if let Some(map) = t {
        for (ptr, new_value) in map {
            if let Some(r) = json_pointer::get_mut(result, ptr) {
                *r = new_value.to_owned();
            }
        }
    }
}
pub fn t_prefix(result: &mut Value, t: Option<&TransPrefix>) {
    if let Some(map) = t {
        for (ptr, prefix) in map {
            let mut p = prefix.to_owned();
            if let Some(r) = json_pointer::get_mut(result, ptr) {
                let current = r.as_str()
                    .expect(&format!("Failed to prefix. Field {ptr} doesn't contain a string"));
#[derive(Deserialize, Serialize, Clone, Debug)]
use serde::{Deserialize, Serialize};

    }
    }
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                }
            }
        })
}
//pub fn update<'a>(doc: &'a mut Yaml, pointer: &'a str) -> Option<&'a mut Yaml> {
//    // Taken from serde JSON
//    if pointer.is_empty() {
//        return Some(doc);
//    }
//    if !pointer.starts_with('/') {
//        return None;
//    }
//    pointer
//        .split('/')
//        .skip(1)
//        .map(|x| x.replace("~1", "/").replace("~0", "~"))
//        .try_fold(doc, |target, token| {
//            match target {
//                Yaml::Hash(map) => {
//                    let t: Yaml = Yaml::from_str(&token).unwrap();
//                    map.get_mut(&t)
//                }
//                Yaml::Sequence(seq) => {
//                    let t: usize = token.parse().unwrap();
//                    seq.get_mut(t)
//                }
//                _ => None,
//            }
//        })
//}
//
//
//pub fn upsert<'a>(doc: &'a mut Yaml, pointer: &'a str) -> Option<&'a mut Yaml> {
//    // Taken from serde JSON
//    if pointer.is_empty() {
//        return Some(doc);
//    }
//    if !pointer.starts_with('/') {
//        return None;
//    }
//    pointer
//        .split('/')
//        .skip(1)
//        .map(|x| x.replace("~1", "/").replace("~0", "~"))
//        .try_fold(doc, |target, token| {
//            match target {
//                Yaml::Hash(map) => {
//                    let t: Yaml = Yaml::from_str(&token).unwrap();
//
//                    if !map.contains_key(&t) {
//                            let next = Yaml::Hash();
//
//                            map.insert(t.to_owned(), Yaml::Hash(next));
//                    }
//
//                    map.get_mut(&t)
//                }
//                Yaml::Sequence(seq) => {
//                    let t: usize = token.parse().unwrap();
//                    seq.get_mut(t)
//                }
//                _ => None,
//            }
//        })
//}
    let mut target_acc = ptr
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get_mut(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get_mut(t)
                }
                _ => {
                    None
                }
            }
        });
    let mut addition_acc: Value;
    ptr
        .windows(2)
        .for_each(|token| {
            if let Ok(n) = token.parse::<usize>() {
            } else if let Ok(s) = token.parse::<str>() {
                if s == "-" {
                } else {
                }
            }
    });
}
pub fn insert<'a>(doc: &'a mut Value, ptr: &'a str, value: &'a Value) {
    if ptr.is_empty() {
        return;
    }
    if !ptr.starts_with('/') {
        return;
    }
                    seq.get_mut(t)
                }
                _ => {
                    None
                    map.get_mut(&t)
    ptr
    if !ptr.starts_with('/') {
        panic!("{} is not a valid pointer", &ptr);
    }
    if ptr.is_empty() {
        panic!("Point is empty");
    ptr
        .split('/')
        .skip(1)
        .map(|x| x.replace("~1", "/").replace("~0", "~"))
        .try_fold(doc, |target, token| {
            match target {
                Value::Mapping(map) => {
                    let t: Value = serde_yaml::from_str(&token).unwrap();
                    map.get(&t)
                }
                Value::Sequence(seq) => {
                    let t: usize = token.parse().unwrap();
                    seq.get(t)
                }
                _ => {
                    None
                }
            }
        })
}
pub fn get_mut<'a>(doc: &'a mut Value, ptr: &'a str) -> Option<&'a mut Value> {
pub fn get<'a>(doc: &'a Value, ptr: &'a str) -> Option<&'a Value> {
    if ptr.is_empty() {
        panic!("Point is empty");
    if !ptr.starts_with('/') {
        panic!("{} is not a valid pointer", &ptr);
    }
use serde::Deserialize;
use serde_yaml::{self, Value, Mapping, Sequence};
use std::collections::HashMap;

use serde::Deserialize;
use serde_yaml::{
    self,
    Value,
};

    str,
    fs,
    path::{Path, PathBuf},
    ffi::OsStr,

    collections::HashMap,
    convert::From,
    env::current_dir,
    hash::Hash,
    path::PathBuf,
    fs

use url::{Url, ParseError};
use serde_yaml::Value;
mod karbonfile;
use karbonfile::*;
mod json_pointer;

use thiserror::Error;

struct CliArgs {
    #[clap(subcommand)]
    command: Command,

#[command()]
struct Cli {
    #[command(subcommand)]
    command: Command

    #[clap(parse(from_os_str))]
    Build { path: PathBuf },

    /// Render one or more karbonfiles
    Build {
        /// Path(s) to one or more karbonfiles
        path: Vec<String>,
    }

fn find_resources(path: &str) -> Vec<Url> {
    match Url::parse(path) {
        Err(ParseError::RelativeUrlWithoutBase) => {
            // If the URL doesn't have a valid base try to parse it as a Path.
            let p = Path::new(path)
                .canonicalize()
                .expect("Unable to canonicalize {p}");

            if p.is_file() {
                let url = Url::from_file_path(p)
                    .expect("Unable to convert {p} to a URL");

#[derive(Error, Debug)]
enum Error {
    #[error(transparent)]
    StdIo(#[from] std::io::Error),
    #[error("{0} is not a valid karbonfile path or directory")]
    InvalidBuildPath(PathBuf),
    #[error(transparent)]
    SerdeError(#[from] serde_yaml::Error),
}

                return vec!(url);
            } else if p.is_dir() {
                let entries = fs::read_dir(p.to_owned())
                    .expect("Unable to list the content of {p}");
                let mut result = Vec::new();

#[derive(Clone, Debug, Deserialize)]
#[serde(untagged)]
enum Document {
    Karbonfile {
        apiVersion: String,
        resources: HashMap<String, Option<ResourceOpts>>,
        #[serde(default)]
        transformations: Vec<Transformation>,
    },
    Other(Value),
}

                for e in entries {
                    let e_path = e.unwrap()
                                    .path()
                                    .to_path_buf();
                    let extension = e_path.extension()
                                    .and_then(OsStr::to_str)
                                    .unwrap_or("");
                    let stem = e_path.file_stem()
                                .and_then(OsStr::to_str)
                                .unwrap_or("");

                    // Ignore non YAML files or files without extensions.
                    if ["yaml", "yml"].contains(&extension) {
                        break;
                    }

#[derive(Clone, Debug, Deserialize)]
#[serde(untagged)]
enum ResourceOpts {}

                    let f_path = p.join(&e_path);
                    let f_url = Url::from_file_path(f_path)
                        .expect("Unable to convert {f_path} to a URL");

                    // If a Karbonfile is found in the directory ignore everything else
                    // and return it for further processing.
                    if stem == "karbonfile" {
                        return vec!(f_url);
                    }

#[derive(Clone, Debug)]
struct File {
    path: PathBuf,
    document: Document,
}

                    // Else return the url of the file to add to the result vec.
                    result.push(f_url);
                }

                return result;
            } else {
                panic!("{p:#?} is neither a file nor a directory");
            }
        }

#[derive(Clone, Debug)]
struct Variant {
    branch: Vec<File>,
    original: Option<File>,
    result: Value,
}

        Err(_) => panic!("Could convert into url {path}"),

impl Variant {
    pub fn new() -> Self {
        Self::default()
    }
}

        Ok(url) => return vec!(url),

impl Default for Variant {
    fn default() -> Self {
        return Self {
            branch: Vec::new(),
            original: None,
            result: Value::Null,
        };

fn parse(url: &Url) -> Value {
    match url.scheme() {
        "file" => {
            let file = fs::File::open(to_path(url))
                .expect("Failed to open the file.");

            serde_yaml::from_reader(file)
                .expect("Failed to parse the file.")
        }
        _ => {
            panic!("Failed to par {url}, remote files are not implemented yet.");
        }

#[derive(Clone, Debug, Deserialize)]
#[serde(untagged, rename_all = "lowercase")]
enum Transformation {
    PatchSet {
        #[serde(default)]
        filters: Vec<Filter>,
        patches: HashMap<JsonPointer, JsonPatch>,

fn resolve_dir(url: &Url) -> Url {
    match url.scheme() {
        "file" => {
            let mut path = to_path(&url);

#[derive(Clone, Debug, Deserialize)]
struct Filter(HashMap<JsonPointer, Value>);

            if path.is_dir() {
                path.push("karbon.yml");
                if path.is_file() {
                    return to_url(&path);
                }

impl Filter {
    pub fn matches(&self, doc: &mut Value) -> bool {
        let Filter(map) = self;

                path.set_extension("yaml");
                if path.is_file() {
                    return to_url(&path);
                }
                panic!("Failed to find any karbonfile.[yml|yaml] files in {url}");
            }
            if path.is_file() {
                return url.to_owned();

        for (ptr, val) in map.into_iter() {
            if *ptr.get_mut(doc) != val.clone() {
                return false;

            panic!("{url} is not a valid file or directory");
        }
        _ => {
            panic!("Remote files are not implemented yet.");

        return true;

fn to_url(path: &PathBuf) -> Url {
    let canonical = path.canonicalize()
        .expect("Failed to canonicalize {path}");

    Url::from_file_path(canonical)
        .expect("Failed to convert {canonical} to a URL")

#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "lowercase")]
enum JsonPatch {
    Add(Value),
    Replace(Value),
    Remove,

fn to_path(url: &Url) -> PathBuf {
    Url::to_file_path(url)
        .expect("Failed to convert {to} to a path")
}

fn merge_url(base: &Url, s: &str) -> Url {
    base.join(s)
        .expect("Failed to merge {url} and {s}")
}

#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq)]
#[serde(try_from = "String")]
struct JsonPointer(Vec<String>);

type VariantVec = Vec<Variant>;

impl JsonPointer {
    pub fn get_mut<'a>(&'a self, doc: &'a mut Value) -> &mut Value {
        let mut result = doc;

fn build_variants(
    original_url: Url,
    mut variant: Variant,
    result: &mut VariantVec) {

        for field in self.fields() {
            result =  result
                .get_mut(field)
                .expect("Field {field} wasn't found");
        }

    let url = resolve_dir(&original_url);
    let doc = parse(&url);

        return result;
    }

    match serde_yaml::from_value(doc) {
        Ok(karbonfile) => {
            let resources = get_resources(&karbonfile);

    fn fields(&self) -> Vec<String> {
        let JsonPointer(fields) = self;

            push_transformations(&mut variant, &url, &karbonfile);

        return fields.clone();
    }
}

            if resources.is_empty() {
                leaf_is_karbonfile_without_resources(result, &variant, &url);
            } else {
                // not a leaf here since it's a karbonfile
                // and there is resources to go through.
                // So start a new branch an keep walking.
                for r in resources {
                    let next = merge_url(&url, &r);
                    build_variants(next, variant.clone(), result);
                }
            }
        }
        Err(e) => {
            leaf_is_not_karbonfile(result, &variant, &url);

impl From<String> for JsonPointer {
    fn from(item: String) -> Self {
        if !item.starts_with("/") {
            panic!("{item} is not a valid JSON pointer. It should start with a '/'");

        let result: Vec<String> = item.split('/')
            .skip(1) // Skip the first item (always an empty string)
            .map(|x| x.to_string())
            .collect();
        
        return JsonPointer(result);

fn get_resources(karbonfile: &Karbonfile) -> Vec<Resource> {
    karbonfile
        .resources
        .iter()
        .map(|k| k.clone())
        .collect()

fn read_file(path: &PathBuf) -> String {
    return fs::read_to_string(path)
        .expect(&format!("Failed to open file {}", path.display()));

fn parse(path: &PathBuf) -> Document {
    let content = read_file(path);
    let result: Document = serde_yaml::from_str(&content).unwrap();

fn push_transformations(variant: &mut Variant, url: &Url, karbonfile: &Karbonfile) {
    let new = (
        url.to_owned(),
        karbonfile.transformations.to_owned()
    );
    match &variant.transformations {
        None => {
            variant.transformations = Some(
                vec!(new)
            );
        }
        Some(t) => {
            let mut new_t = t.to_owned();
            new_t.push(new);
            variant.transformations = Some(new_t);
        }
    }

    return result;

fn leaf_is_not_karbonfile(result: &mut VariantVec, variant: &Variant, url: &Url) {
    // Leaf since it's not a karbonfile.
    // Set the path and push the branch to result
    let mut v = variant.to_owned();

    v.original = Some(parse(&url));
    v.url = Some(url.to_owned());
    v.apply_transformations();
    result.push(v);

fn normalize(root: &PathBuf, input: &str) -> PathBuf {
    let mut result =  root.clone();
    if result.is_file() {
        result.pop();
    };
    result.push(input);
    return result
        .canonicalize()
        .expect(&format!("Failed to normalize {}", result.display()));

fn run(path: PathBuf, result: &mut Vec<Variant>, variant: Variant) {
    let document = parse(&path);
    let file = File {
        path: path.clone(),
        document: document.clone(),
    };

fn leaf_is_karbonfile_without_resources(result: &mut VariantVec, variant: &Variant, url: &Url) {
    // leaf since it's a karbonfile but there
    // is no resources in it. 
    // Set the path and push the branch to result
    let mut v = variant.to_owned();

    match document {
        Document::Karbonfile { resources: resources, .. } => {
            let mut branch = variant.branch;
            branch.push(file);

    v.url = Some(url.to_owned());
    result.push(v);

            let mut new_variant = Variant {
                branch: branch,
                ..variant
            };
            for r in resources.keys() {
                run(normalize(&path, r), result, new_variant.clone());
            };
        },
        Document::Other(_) => {
            let mut new_variant = Variant {
                original: Some(file),
                ..variant
            };
            result.push(new_variant);
        },
    };

    let cli = CliArgs::parse();

    let cli = Cli::parse();
    let root = current_dir().unwrap();

            let mut result: VariantVec = Vec::new();
            
            build_variants(to_url(&path), Variant::new(), &mut result);

            let mut result = Vec::new();

            for r in &result {
                if let Some(x) = &r.result {
                    println!("{}", serde_yaml::to_string(&x).unwrap());
                }
            }

            for p in path {
                let normalized = normalize(&root, &p);
                run(normalized, &mut result, Variant::new());
            };
            println!("{:#?}", result);

    };
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn valid_jsonpointer() {
        assert_eq!(
            JsonPointer::from("/a/b/c".to_string()),
            JsonPointer(vec!["a".to_string(), "b".to_string(), "c".to_string()])
        );

clap = { version = "3.0", features = ["derive"] }
url = { version = "2", features = ["serde"] }
minreq = { version = "2.5.1", features = ["https", "punycode"] }
serde = { version = "1.0", features = ["derive"] }
serde_yaml = "0.8"

clap = { version = "4.0.18", features = ["derive"] }
serde = { version = "1.0.147", features = ["derive"] }
serde_with = "2.0.1"
serde_yaml = "0.9.14"
thiserror = "1.0.37"

name = "android_system_properties"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
dependencies = [
 "libc",
]
[[package]]

version = "1.0.1"

version = "1.1.0"

checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
[[package]]
name = "base64"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"

version = "3.9.1"

version = "3.11.1"

checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"

checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"

version = "1.0.73"

version = "1.0.74"

checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"

checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574"

[[package]]
name = "chrono"
version = "0.4.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"
dependencies = [
 "iana-time-zone",
 "num-integer",
 "num-traits",
 "serde",
 "winapi",
]

version = "3.0.13"

version = "4.0.18"

checksum = "08799f92c961c7a1cf0cc398a9073da99e21ce388b46372c37f3191f2f3eed3e"

checksum = "335867764ed2de42325fafe6d18b8af74ba97ee0c590fa016f157535b42ab04b"

 "indexmap",
 "lazy_static",
 "os_str_bytes",

 "clap_lex",
 "once_cell",

 "textwrap",

version = "3.0.12"

version = "4.0.18"

checksum = "0fd2078197a22f338bd4fbf7d6387eb6f0d6a3c69e6cbc09f5c93e97321fd92a"

checksum = "16a1b0f6422af32d5da0c58e2703320f379216ee70198241c84173a8c5ac28f3"

name = "form_urlencoded"
version = "1.0.1"

name = "clap_lex"
version = "0.3.0"

checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"

checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"

 "matches",
 "percent-encoding",

 "os_str_bytes",
]
[[package]]
name = "codespan-reporting"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
dependencies = [
 "termcolor",
 "unicode-width",
]
[[package]]
name = "core-foundation-sys"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
[[package]]
name = "cxx"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"
dependencies = [
 "cc",
 "cxxbridge-flags",
 "cxxbridge-macro",
 "link-cplusplus",
]
[[package]]
name = "cxx-build"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"
dependencies = [
 "cc",
 "codespan-reporting",
 "once_cell",
 "proc-macro2",
 "quote",
 "scratch",
 "syn",
]
[[package]]
name = "cxxbridge-flags"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"
[[package]]
name = "cxxbridge-macro"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]
name = "darling"
version = "0.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa"
dependencies = [
 "darling_core",
 "darling_macro",
]
[[package]]
name = "darling_core"
version = "0.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f"
dependencies = [
 "fnv",
 "ident_case",
 "proc-macro2",
 "quote",
 "strsim",
 "syn",
]
[[package]]
name = "darling_macro"
version = "0.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e"
dependencies = [
 "darling_core",
 "quote",
 "syn",

name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]

version = "0.11.2"

version = "0.12.3"

checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"

checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"

name = "idna"
version = "0.2.3"

name = "hex"
version = "0.4.3"

checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"

checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
[[package]]
name = "iana-time-zone"
version = "0.1.53"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"

 "matches",
 "unicode-bidi",
 "unicode-normalization",

 "android_system_properties",
 "core-foundation-sys",
 "iana-time-zone-haiku",
 "js-sys",
 "wasm-bindgen",
 "winapi",

[[package]]
name = "iana-time-zone-haiku"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
dependencies = [
 "cxx",
 "cxx-build",
]
[[package]]
name = "ident_case"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

version = "1.8.0"

version = "1.9.1"

checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"

checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"

 "serde",

name = "itoa"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"
[[package]]

version = "0.3.56"

version = "0.3.60"

checksum = "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"

checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"

 "minreq",

 "serde_with",

 "url",

 "thiserror",

name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]

version = "0.2.115"

version = "0.2.137"

checksum = "0a8d982fa7a96a000f6ec4cfe966de9703eccde29750df2bb8949da91b0e818d"

checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"

name = "linked-hash-map"
version = "0.5.4"

name = "link-cplusplus"
version = "1.0.7"

checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"

checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
dependencies = [
 "cc",
]

version = "0.4.14"

version = "0.4.17"

checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"

checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"

name = "matches"
version = "0.1.9"

name = "num-integer"
version = "0.1.45"

checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"

checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
dependencies = [
 "autocfg",
 "num-traits",
]

name = "memchr"
version = "2.4.1"

name = "num-traits"
version = "0.2.15"

checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"

checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
dependencies = [
 "autocfg",
]

name = "minreq"
version = "2.5.1"

name = "num_threads"
version = "0.1.6"

checksum = "086dde2aacc3ce84b680e76ef4a60d77e75cb8109e5a508cc7ea81a86d65fd0d"

checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44"

 "lazy_static",
 "log",
 "punycode",
 "rustls",
 "webpki",
 "webpki-roots",

 "libc",

version = "1.9.0"

version = "1.16.0"

checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"

checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"

version = "6.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
dependencies = [
 "memchr",
]
[[package]]
name = "percent-encoding"
version = "2.1.0"

version = "6.3.1"

checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"

checksum = "3baf96e39c5359d2eb0dd6ccb42c62b91d9678aa68160d261b9e0ccbf9e9dea9"

version = "1.0.36"

version = "1.0.47"

checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"

checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"

 "unicode-xid",

 "unicode-ident",

[[package]]
name = "punycode"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e9e1dcb320d6839f6edb64f7a4a59d39b30480d4d1765b56873f7c858538a5fe"

version = "1.0.15"

version = "1.0.21"

checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"

checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"

name = "ring"
version = "0.16.20"

name = "ryu"
version = "1.0.11"

checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
dependencies = [
 "cc",
 "libc",
 "once_cell",
 "spin",
 "untrusted",
 "web-sys",
 "winapi",
]

checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
[[package]]
name = "scratch"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"

name = "rustls"
version = "0.20.3"

name = "serde"
version = "1.0.147"

checksum = "b323592e3164322f5b193dc4302e4e36cd8d37158a712d664efae1a5c2791700"

checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965"

 "log",
 "ring",
 "sct",
 "webpki",

 "serde_derive",

name = "ryu"
version = "1.0.9"

name = "serde_derive"
version = "1.0.147"

checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"

checksum = "4f1d362ca8fc9c3e3a7484440752472d68a6caa98f1ab81d99b5dfe517cec852"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]

name = "sct"
version = "0.7.0"

name = "serde_json"
version = "1.0.87"

checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"

checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45"

 "ring",
 "untrusted",

 "itoa",
 "ryu",
 "serde",

name = "serde"
version = "1.0.136"

name = "serde_with"
version = "2.0.1"

checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"

checksum = "368f2d60d049ea019a84dcd6687b0d1e0030fe663ae105039bdf967ed5e6a9a7"

 "serde_derive",

 "base64",
 "chrono",
 "hex",
 "indexmap",
 "serde",
 "serde_json",
 "serde_with_macros",
 "time",

name = "serde_derive"
version = "1.0.136"

name = "serde_with_macros"
version = "2.0.1"

checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"

checksum = "1ccadfacf6cf10faad22bbadf55986bdd0856edfb5d9210aa1dcf1f516e84e93"

 "darling",

version = "0.8.23"

version = "0.9.14"

checksum = "a4a521f2940385c165a24ee286aa8599633d162077a54bdcae2a6fd5a7bfa7a0"

checksum = "6d232d893b10de3eb7258ff01974d6ee20663d8e833263c99409d4b13a0209da"

 "itoa",

 "yaml-rust",

 "unsafe-libyaml",

name = "spin"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
[[package]]

version = "1.0.86"

version = "1.0.103"

checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"

checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"

 "unicode-xid",

 "unicode-ident",

version = "1.1.2"

version = "1.1.3"

checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"

checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"

name = "textwrap"
version = "0.14.2"

name = "thiserror"
version = "1.0.37"

checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"

checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
dependencies = [
 "thiserror-impl",
]

name = "tinyvec"
version = "1.5.1"

name = "thiserror-impl"
version = "1.0.37"

checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"

checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"

 "tinyvec_macros",

 "proc-macro2",
 "quote",
 "syn",

name = "tinyvec_macros"
version = "0.1.0"

name = "time"
version = "0.3.16"

checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"

checksum = "0fab5c8b9980850e06d92ddbe3ab839c062c801f3927c0fb8abd6fc8e918fbca"
dependencies = [
 "itoa",
 "libc",
 "num_threads",
 "serde",
 "time-core",
 "time-macros",
]

name = "unicode-bidi"
version = "0.3.7"

name = "time-core"
version = "0.1.0"

checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"

checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"

name = "unicode-normalization"
version = "0.1.19"

name = "time-macros"
version = "0.2.5"

checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"

checksum = "65bb801831d812c562ae7d2bfb531f26e66e4e1f6b17307ba4149c5064710e5b"

 "tinyvec",

 "time-core",

name = "unicode-xid"
version = "0.2.2"

name = "unicode-ident"
version = "1.0.5"

checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"

checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"

name = "untrusted"
version = "0.7.1"

name = "unicode-width"
version = "0.1.10"

checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"

checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"

name = "url"
version = "2.2.2"

name = "unsafe-libyaml"
version = "0.2.4"

checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
dependencies = [
 "form_urlencoded",
 "idna",
 "matches",
 "percent-encoding",
 "serde",
]

checksum = "c1e5fa573d8ac5f1a856f8d7be41d390ee973daf97c806b2c1a465e4e1406e68"

version = "0.2.79"

version = "0.2.83"

checksum = "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"

checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"

version = "0.2.79"

version = "0.2.83"

checksum = "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"

checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"

 "lazy_static",

 "once_cell",

version = "0.2.79"

version = "0.2.83"

checksum = "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"

checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"

version = "0.2.79"

version = "0.2.83"

checksum = "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"

checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"

version = "0.2.79"

version = "0.2.83"

checksum = "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"

checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"

name = "web-sys"
version = "0.3.56"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c060b319f29dd25724f09a2ba1418f142f539b2be99fbf4d2d5a8f7330afb8eb"
dependencies = [
 "js-sys",
 "wasm-bindgen",
]
[[package]]
name = "webpki"
version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
dependencies = [
 "ring",
 "untrusted",
]
[[package]]
name = "webpki-roots"
version = "0.22.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "552ceb903e957524388c4d3475725ff2c8b7960922063af6ce53c9a43da07449"
dependencies = [
 "webpki",
]
[[package]]

[[package]]
name = "yaml-rust"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
dependencies = [
 "linked-hash-map",
]