@ape-egg/vibe 2.3.0 → 3.0.0

package/compiler/src/compiler/manifest_builder.rs

@@ -1,693 +0,0 @@
-use html5ever::parse_document;
-use html5ever::tendril::TendrilSink;
-use markup5ever_rcdom::{RcDom, NodeData, Handle};
-use regex::Regex;
-use serde::{Serialize, Serializer};
-use serde_json::Value;
-use std::cell::RefCell;
-use std::collections::{HashMap, BTreeMap};
-use crate::compiler::iteration_optimizer::build_iteration_optimizations;
-
-pub struct ManifestBuilder {
-    binding_regex: Regex,
-    name_binding_fix_regex: Regex,
-    /// Original-cased `@[...]` bindings captured from the pre-parse HTML, keyed by
-    /// their lowercased form — used to undo html5ever's attribute-name lowercasing
-    /// of name bindings on every string this builder serializes back out.
-    binding_cases: RefCell<HashMap<String, String>>,
-}
-
-impl ManifestBuilder {
-    pub fn new() -> Self {
-        Self {
-            binding_regex: Regex::new(r"@\[((?:[^\[\]]|\[[^\]]*\])+)\]").unwrap(),
-            name_binding_fix_regex: Regex::new(r#"(@\[[^\]]+\])="+"#).unwrap(),
-            binding_cases: RefCell::new(HashMap::new()),
-        }
-    }
-
-    pub fn build_from_html(&self, html: &str, _state: &Value, iterations_as_is: bool) -> Result<ManifestNode, String> {
-        // Snapshot original-cased bindings before html5ever lowercases name
-        // bindings (attr-name position). Restored on serialized templates and on
-        // the captured name_bindings array.
-        *self.binding_cases.borrow_mut() = crate::compiler::binding_case::capture(html);
-
-        // Parse HTML
-        let dom = parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .read_from(&mut html.as_bytes())
-            .map_err(|e| format!("Failed to parse HTML: {:?}", e))?;
-
-        // Walk tree starting from document root
-        let mut root_node = self.walk_node(&dom.document, &mut 0);
-
-        // Inject compiled batch functions directly into iteration nodes (unless disabled)
-        if !iterations_as_is {
-            let compiled_functions = build_iteration_optimizations(html);
-            if let Some(optimizations) = compiled_functions {
-                self.inject_compiled_functions(&mut root_node, &optimizations.iterations);
-            }
-        }
-
-        Ok(root_node)
-    }
-
-    /// Recursively inject compiled batch functions into iteration nodes
-    fn inject_compiled_functions(&self, node: &mut ManifestNode, compiled_map: &HashMap<String, crate::compiler::iteration_optimizer::CompiledIteration>) {
-        // Check if this is an iteration node with a template
-        if node.node_type.as_deref() == Some("iteration") {
-            if let Some(ref mut compiled_data) = node.compiled {
-                if let Some(ref restoration) = compiled_data.restoration {
-                    if let Some(ref template) = restoration.template {
-                        // Generate hash for this template (same logic as optimizer)
-                        let template_hash = self.generate_template_hash(template);
-
-                        // Look up compiled function
-                        if let Some(compiled) = compiled_map.get(&template_hash) {
-                            compiled_data.iterations = Some(IterationData {
-                                batch_fn: Some(compiled.batch_fn.clone()),
-                                item_alias: Some(compiled.item_alias.clone()),
-                                index_alias: Some(compiled.index_alias.clone()),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-
-        // Recursively process children
-        for child in node.children.values_mut() {
-            self.inject_compiled_functions(child, compiled_map);
-        }
-    }
-
-    /// Generate stable hash for template (matches iteration_optimizer logic)
-    fn generate_template_hash(&self, template: &str) -> String {
-        use std::collections::hash_map::DefaultHasher;
-        use std::hash::{Hash, Hasher};
-
-        let mut hasher = DefaultHasher::new();
-        template.trim().hash(&mut hasher);
-        let hash = hasher.finish();
-        format!("iter_{:x}", hash)
-    }
-
-    fn walk_node(&self, node: &Handle, _counter: &mut usize) -> ManifestNode {
-        self.walk_node_impl(node, &node.children.borrow())
-    }
-
-    fn walk_node_impl(&self, node: &Handle, siblings: &[Handle]) -> ManifestNode {
-        let mut manifest_node = ManifestNode {
-            element: None,
-            parsed: vec![],
-            children: BTreeMap::new(),
-            compiled: None,
-            node_type: None,
-            attributes: None,
-            name_bindings: None,
-            meta: None,
-            runtime: None,
-        };
-
-        match &node.data {
-            NodeData::Text { contents } => {
-                let text = contents.borrow().to_string();
-
-                // Check for @[...] bindings
-                if self.binding_regex.is_match(&text) {
-                    let parsed = self.split_by_bindings(&text);
-                    manifest_node.compiled = Some(CompiledData {
-                        restoration: Some(RestorationData {
-                            parsed: Some(parsed),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    });
-                }
-            }
-
-            NodeData::Element { name, attrs, .. } => {
-                let _tag_name = name.local.to_string();
-
-                // Check attribute bindings (both value and name bindings)
-                let mut attr_bindings = BTreeMap::new();
-                let mut name_bindings: Vec<Option<String>> = Vec::new();
-                let borrowed_attrs = attrs.borrow();
-
-                for (idx, attr) in borrowed_attrs.iter().enumerate() {
-                    let attr_name = attr.name.local.to_string();
-                    let attr_value = attr.value.to_string();
-
-                    // A relocated name-binding: its expression(s) live verbatim in the
-                    // VALUE of data-vibe-namebind because whitespace barred them from
-                    // attribute-name position. Treat the value as the name-binding — no
-                    // case restoration needed (value attrs keep their case).
-                    if attr_name == crate::compiler::name_binding_protect::NAME_BIND_ATTR {
-                        while name_bindings.len() <= idx {
-                            name_bindings.push(None);
-                        }
-                        name_bindings[idx] = Some(attr_value);
-                    }
-                    // Check for name bindings (binding in attribute NAME)
-                    else if self.binding_regex.is_match(&attr_name) {
-                        // Extend vec to include this index
-                        while name_bindings.len() <= idx {
-                            name_bindings.push(None);
-                        }
-                        // html5ever lowercased the attr name; restore original casing.
-                        let restored = crate::compiler::binding_case::restore(
-                            &attr_name,
-                            &self.binding_cases.borrow(),
-                        );
-                        name_bindings[idx] = Some(restored);
-                    }
-                    // Check for attribute value bindings
-                    else if self.binding_regex.is_match(&attr_value) {
-                        attr_bindings.insert(attr_name, attr_value);
-                    }
-                }
-
-                // Store if we have any bindings
-                let has_name_bindings = name_bindings.iter().any(|b| b.is_some());
-
-                // Set runtime-compatible fields at node level
-                if !attr_bindings.is_empty() {
-                    manifest_node.attributes = Some(attr_bindings.clone());
-                }
-                if has_name_bindings {
-                    manifest_node.name_bindings = Some(name_bindings.clone());
-                }
-
-                // Also store in compiled.restoration for restoration purposes
-                if !attr_bindings.is_empty() || has_name_bindings {
-                    manifest_node.compiled = Some(CompiledData {
-                        restoration: Some(RestorationData {
-                            attributes: if !attr_bindings.is_empty() { Some(attr_bindings) } else { None },
-                            name_bindings: if has_name_bindings { Some(name_bindings) } else { None },
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    });
-                }
-            }
-
-            NodeData::Comment { contents } => {
-                let comment = contents.to_string();
-                let trimmed = comment.trim();
-
-                // Check for iteration: <!-- each items as item -->
-                if trimmed.starts_with("each ") {
-                    manifest_node.node_type = Some("iteration".to_string());
-
-                    // Extract expression: "each items as item" -> "items as item"
-                    let expression = trimmed.strip_prefix("each ").unwrap_or("").to_string();
-
-                    // Parse expression to extract parts: "items as item, index" or "items as item".
-                    // The optional (key) expression may sit before or after the index — strip it
-                    // first so the item/index split isn't polluted by it. The key itself isn't
-                    // stored here; the runtime re-derives it from the preserved comment.
-                    let parts: Vec<&str> = expression.split(" as ").collect();
-                    let array_path = parts.get(0).unwrap_or(&"").trim().to_string();
-                    let alias_part = parts.get(1).unwrap_or(&"").trim();
-                    let alias_without_key = match (alias_part.find('('), alias_part.rfind(')')) {
-                        (Some(open), Some(close)) if close > open => {
-                            format!("{}{}", &alias_part[..open], &alias_part[close + 1..])
-                        }
-                        _ => alias_part.to_string(),
-                    };
-                    let alias_without_key = alias_without_key.trim();
-                    let (item_alias, index_alias) = if let Some(comma_pos) = alias_without_key.find(',') {
-                        let item = alias_without_key[..comma_pos].trim().to_string();
-                        let index = alias_without_key[comma_pos + 1..].trim().to_string();
-                        (item, index)
-                    } else {
-                        (alias_without_key.to_string(), "index".to_string())
-                    };
-
-                    // Find node index in siblings
-                    let node_idx = siblings.iter().position(|n| std::ptr::eq(n as *const _, node as *const _));
-
-                    // Extract template if we can find this node in siblings
-                    let template = if let Some(idx) = node_idx {
-                        self.extract_template_from_siblings(siblings, idx, "each ", "/each")
-                    } else {
-                        String::new()
-                    };
-
-                    // Create minimal meta structure - runtime will populate template after parsing restored DOM
-                    manifest_node.meta = Some(serde_json::json!({
-                        "arrayPath": array_path,
-                        "itemAlias": item_alias,
-                        "indexAlias": index_alias
-                    }));
-
-                    // Runtime state
-                    manifest_node.runtime = Some(serde_json::json!({
-                        "instances": [],
-                        "templateRemoved": false
-                    }));
-
-                    // Compiled restoration data
-                    manifest_node.compiled = Some(CompiledData {
-                        restoration: Some(RestorationData {
-                            template: Some(template),
-                            expression: Some(expression),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    });
-                }
-
-                // Check for conditionals: <!-- if condition -->
-                if trimmed.starts_with("if ") {
-                    manifest_node.node_type = Some("conditional".to_string());
-
-                    let expression = trimmed.strip_prefix("if ").unwrap_or("").to_string();
-                    let node_idx = siblings.iter().position(|n| std::ptr::eq(n as *const _, node as *const _));
-
-                    let template = if let Some(idx) = node_idx {
-                        self.extract_template_from_siblings(siblings, idx, "if ", "/if")
-                    } else {
-                        String::new()
-                    };
-
-                    // Create minimal meta structure - runtime will populate branches after parsing restored DOM
-                    manifest_node.meta = Some(serde_json::json!({
-                        "expression": expression
-                    }));
-
-                    // Runtime state
-                    manifest_node.runtime = Some(serde_json::json!({
-                        "activeBranch": null,
-                        "activeInstance": null,
-                        "templateRemoved": false
-                    }));
-
-                    // Compiled restoration data
-                    manifest_node.compiled = Some(CompiledData {
-                        restoration: Some(RestorationData {
-                            template: Some(template),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    });
-                }
-            }
-
-            _ => {}
-        }
-
-        // Recursively process children using local indices (to match runtime key generation)
-        let children = node.children.borrow();
-        let mut skip_indices = std::collections::HashSet::new();
-
-        // First pass: identify indices to skip (iteration/conditional template content)
-        for (i, child) in children.iter().enumerate() {
-            if let NodeData::Comment { contents } = &child.data {
-                let trimmed = contents.trim();
-
-                // Find iteration blocks and mark template indices to skip
-                if trimmed.starts_with("each ") {
-                    if let Some(end_idx) = self.find_matching_end(&children, i, "each ", "/each") {
-                        // Skip all nodes between start and end comments (including end comment)
-                        for j in (i + 1)..=end_idx {
-                            skip_indices.insert(j);
-                        }
-                    }
-                }
-
-                // Find conditional blocks and mark template indices to skip
-                if trimmed.starts_with("if ") {
-                    if let Some(end_idx) = self.find_matching_end(&children, i, "if ", "/if") {
-                        for j in (i + 1)..=end_idx {
-                            skip_indices.insert(j);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Second pass: process children that aren't skipped
-        for (local_index, child) in children.iter().enumerate() {
-            if skip_indices.contains(&local_index) {
-                continue;
-            }
-
-            let child_key = self.generate_child_key(child, &local_index);
-            manifest_node.children.insert(
-                child_key.clone(),
-                self.walk_node_impl(child, &children)
-            );
-        }
-
-        manifest_node
-    }
-
-    /// Split text by @[...] bindings: "Hello @[name]!" -> ["Hello ", "@[name]", "!"]
-    fn split_by_bindings(&self, text: &str) -> Vec<String> {
-        let mut result = vec![];
-        let mut last_end = 0;
-
-        for mat in self.binding_regex.find_iter(text) {
-            // Add text before match
-            if mat.start() > last_end {
-                result.push(text[last_end..mat.start()].to_string());
-            }
-            // Add binding
-            result.push(mat.as_str().to_string());
-            last_end = mat.end();
-        }
-
-        // Add remaining text
-        if last_end < text.len() {
-            result.push(text[last_end..].to_string());
-        }
-
-        result
-    }
-
-    /// Generate child key: "text_0", "div_1", etc.
-    fn generate_child_key(&self, node: &Handle, index: &usize) -> String {
-        match &node.data {
-            NodeData::Text { .. } => format!("text_{}", index),
-            NodeData::Element { name, .. } => {
-                format!("{}_{}", name.local.to_lowercase(), index)
-            }
-            NodeData::Comment { contents } => {
-                let trimmed = contents.trim();
-                if trimmed.starts_with("each ") {
-                    format!("iteration_{}", index)
-                } else if trimmed.starts_with("if ") {
-                    format!("conditional_{}", index)
-                } else {
-                    format!("comment_{}", index)
-                }
-            }
-            _ => format!("node_{}", index),
-        }
-    }
-
-    /// Find the index of matching end comment
-    fn find_matching_end(&self, siblings: &[Handle], start_idx: usize, start_marker: &str, end_marker: &str) -> Option<usize> {
-        let mut depth = 0;
-
-        for (idx, sibling) in siblings.iter().enumerate().skip(start_idx + 1) {
-            if let NodeData::Comment { contents } = &sibling.data {
-                let trimmed = contents.trim();
-                if trimmed.starts_with(start_marker) {
-                    depth += 1;
-                } else if trimmed == end_marker {
-                    if depth == 0 {
-                        return Some(idx);
-                    } else {
-                        depth -= 1;
-                    }
-                }
-            }
-        }
-
-        None
-    }
-
-    /// Extract template between start and end comments (generic for iterations and conditionals)
-    fn extract_template_from_siblings(&self, siblings: &[Handle], start_idx: usize, start_marker: &str, end_marker: &str) -> String {
-        // Find matching end comment
-        let mut depth = 0;
-        let mut end_idx = None;
-
-        for (idx, sibling) in siblings.iter().enumerate().skip(start_idx + 1) {
-            if let NodeData::Comment { contents } = &sibling.data {
-                let trimmed = contents.trim();
-                if trimmed.starts_with(start_marker) {
-                    depth += 1;
-                } else if trimmed == end_marker {
-                    if depth == 0 {
-                        end_idx = Some(idx);
-                        break;
-                    } else {
-                        depth -= 1;
-                    }
-                }
-            }
-        }
-
-        // Extract template HTML between start and end — VERBATIM, including
-        // whitespace-only text nodes. The manifest's child keys are childNodes
-        // indices computed on the pre-stamp DOM; restoration re-inserts this
-        // template, and only an exact node-count round-trip keeps those
-        // indices valid for every sibling that follows the restored region.
-        if let Some(end) = end_idx {
-            let template_nodes: Vec<_> = siblings.iter()
-                .skip(start_idx + 1)
-                .take(end - start_idx - 1)
-                .collect();
-
-            return self.serialize_nodes(&template_nodes);
-        }
-
-        String::new()
-    }
-
-    /// Serialize nodes to HTML string
-    fn serialize_nodes(&self, nodes: &[&Handle]) -> String {
-        use html5ever::serialize::{serialize, SerializeOpts, TraversalScope};
-        use markup5ever_rcdom::SerializableHandle;
-
-        let mut html = String::new();
-
-        for node in nodes.iter() {
-            let mut bytes = Vec::new();
-
-            // Serialize with IncludeNode to include the element tags
-            let opts = SerializeOpts {
-                traversal_scope: TraversalScope::IncludeNode,
-                ..Default::default()
-            };
-
-            let serializable = SerializableHandle::from((*node).clone());
-            serialize(&mut bytes, &serializable, opts).ok();
-
-            if let Ok(node_html) = String::from_utf8(bytes) {
-                html.push_str(&node_html);
-            }
-        }
-
-        // Fix name bindings: Remove ="" added by html5ever serializer
-        // Name bindings like <icon @[section.icon]> get serialized as <icon @[section.icon]="">
-        // which is invalid HTML that browsers reject
-        html = self.name_binding_fix_regex.replace_all(&html, "$1").to_string();
-
-        // Restore original casing of any name-binding expressions html5ever
-        // lowercased while parsing (attr-name position).
-        html = crate::compiler::binding_case::restore(&html, &self.binding_cases.borrow());
-
-        html
-    }
-}
-
-#[derive(Debug)]
-pub struct ManifestNode {
-    element: Option<()>,  // Always null in static manifest
-    parsed: Vec<String>,
-    children: BTreeMap<String, ManifestNode>,
-
-    #[allow(dead_code)]
-    compiled: Option<CompiledData>,
-
-    #[allow(dead_code)]
-    node_type: Option<String>,
-
-    // Runtime-compatible fields
-    #[allow(dead_code)]
-    attributes: Option<BTreeMap<String, String>>,
-
-    #[allow(dead_code)]
-    name_bindings: Option<Vec<Option<String>>>,
-
-    #[allow(dead_code)]
-    meta: Option<Value>,  // For conditionals and iterations
-
-    #[allow(dead_code)]
-    runtime: Option<Value>,  // Runtime state
-}
-
-// Custom Serialize implementation to control output format
-impl Serialize for ManifestNode {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use serde::ser::SerializeMap;
-
-        let mut map = serializer.serialize_map(None)?;
-
-        // Always include element (null)
-        map.serialize_entry("element", &self.element)?;
-
-        // Always include parsed (empty array if no data)
-        map.serialize_entry("parsed", &self.parsed)?;
-
-        // Always include children
-        map.serialize_entry("children", &self.children)?;
-
-        // Optional: attributes (runtime field)
-        if let Some(ref attributes) = self.attributes {
-            map.serialize_entry("attributes", attributes)?;
-        }
-
-        // Optional: nameBindings (runtime field)
-        if let Some(ref name_bindings) = self.name_bindings {
-            map.serialize_entry("nameBindings", name_bindings)?;
-        }
-
-        // Optional: meta (runtime field for conditionals/iterations)
-        if let Some(ref meta) = self.meta {
-            map.serialize_entry("meta", meta)?;
-        }
-
-        // Optional: runtime (runtime state)
-        if let Some(ref runtime) = self.runtime {
-            map.serialize_entry("runtime", runtime)?;
-        }
-
-        // Optional: compiled (contains restoration and iterations data)
-        if let Some(ref compiled) = self.compiled {
-            map.serialize_entry("compiled", compiled)?;
-        }
-
-        // Optional: type
-        if let Some(ref node_type) = self.node_type {
-            map.serialize_entry("type", node_type)?;
-        }
-
-        map.end()
-    }
-}
-
-#[derive(Debug, Serialize, Default)]
-pub struct RestorationData {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub parsed: Option<Vec<String>>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub attributes: Option<BTreeMap<String, String>>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub template: Option<String>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub expression: Option<String>,
-
-    #[serde(skip_serializing_if = "Option::is_none", rename = "nameBindings")]
-    pub name_bindings: Option<Vec<Option<String>>>,
-}
-
-#[derive(Debug, Serialize, Default)]
-pub struct IterationData {
-    #[serde(skip_serializing_if = "Option::is_none", rename = "batchFn")]
-    pub batch_fn: Option<String>,
-
-    #[serde(skip_serializing_if = "Option::is_none", rename = "itemAlias")]
-    pub item_alias: Option<String>,
-
-    #[serde(skip_serializing_if = "Option::is_none", rename = "indexAlias")]
-    pub index_alias: Option<String>,
-}
-
-#[derive(Debug, Serialize, Default)]
-pub struct CompiledData {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub restoration: Option<RestorationData>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub iterations: Option<IterationData>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn build_simple_text_binding() {
-        let html = r#"<div>Hello @[name]</div>"#;
-        let state = json!({ "name": "World" });
-        let builder = ManifestBuilder::new();
-        let manifest = builder.build_from_html(html, &state, false).unwrap();
-
-        // Should have children
-        assert!(!manifest.children.is_empty());
-    }
-
-    #[test]
-    fn build_attribute_binding() {
-        let html = r#"<input value="@[firstName]">"#;
-        let state = json!({ "firstName": "John" });
-        let builder = ManifestBuilder::new();
-        let manifest = builder.build_from_html(html, &state, false).unwrap();
-
-        // Should have children
-        assert!(!manifest.children.is_empty());
-    }
-
-    #[test]
-    fn build_iteration_with_template() {
-        let html = r#"<body><!-- each items as item --><div>@[item]</div><!-- /each --></body>"#;
-        let state = json!({ "items": [1, 2, 3] });
-        let builder = ManifestBuilder::new();
-        let manifest = builder.build_from_html(html, &state, false).unwrap();
-
-        // Serialize to JSON to inspect
-        let json = serde_json::to_string_pretty(&manifest).unwrap();
-        eprintln!("Manifest JSON:\n{}", json);
-
-        // Find iteration node
-        // Note: might be nested under body
-        assert!(!manifest.children.is_empty());
-    }
-
-    #[test]
-    fn split_bindings_simple() {
-        let builder = ManifestBuilder::new();
-        let result = builder.split_by_bindings("Hello @[name]!");
-        assert_eq!(result, vec!["Hello ", "@[name]", "!"]);
-    }
-
-    #[test]
-    fn split_bindings_multiple() {
-        let builder = ManifestBuilder::new();
-        let result = builder.split_by_bindings("@[firstName] @[lastName]");
-        assert_eq!(result, vec!["@[firstName]", " ", "@[lastName]"]);
-    }
-
-    #[test]
-    fn split_bindings_no_match() {
-        let builder = ManifestBuilder::new();
-        let result = builder.split_by_bindings("Hello World");
-        assert_eq!(result, vec!["Hello World"]);
-    }
-
-    #[test]
-    fn build_multiple_name_bindings() {
-        let html = r#"<div test @[theme] @[size]></div>"#;
-        let state = json!({ "theme": "light", "size": "large" });
-        let builder = ManifestBuilder::new();
-        let manifest = builder.build_from_html(html, &state, false).unwrap();
-
-        // Navigate to div
-        let html_node = manifest.children.get("html_0").unwrap();
-        let body_node = html_node.children.get("body_1").unwrap();
-        let div_node = body_node.children.get("div_0").unwrap();
-
-        // Check name bindings (sparse array indexed by position)
-        let compiled = div_node.compiled.as_ref().unwrap();
-        let restoration = compiled.restoration.as_ref().unwrap();
-        let name_bindings = restoration.name_bindings.as_ref().unwrap();
-
-        // Attributes: [0] test, [1] @[theme], [2] @[size]
-        assert_eq!(name_bindings.len(), 3);
-        assert_eq!(name_bindings[0], None);  // "test" is not a binding
-        assert_eq!(name_bindings[1], Some("@[theme]".to_string()));
-        assert_eq!(name_bindings[2], Some("@[size]".to_string()));
-    }
-}