code-gauge 5.0.0 → 5.1.0

package/native/Cargo.toml

@@ -16,27 +16,22 @@ regex = "1"
 rustc-hash = "2"
 
 # Grammar crates are pinned exactly: every metric (and the golden-based test suite) is calibrated
-# against these grammar versions, so upgrades are deliberate, test-verified changes. The Kotlin
-# grammar is WillBooster's fork, which is not on crates.io, pinned to a release tag. Core 0.25 is
-# the first to load that grammar's ABI 15 parser, and tree-sitter-javascript 0.21.x pins
-# `cc ~1.0`, which conflicts with the core's `cc ^1.2`, hence 0.25.0. The core reports no field for
-# extra (error-recovery) children in ts_node_field_name_for_child, which
-# util::find_children_by_field_name compensates for.
-tree-sitter = "=0.25.10"
-tree-sitter-c = "=0.21.4"
-tree-sitter-c-sharp = "=0.21.3"
-tree-sitter-cpp = "=0.22.3"
-tree-sitter-go = "=0.21.2"
-tree-sitter-java = "=0.21.0"
-tree-sitter-kotlin = { package = "willbooster-tree-sitter-kotlin", git = "https://github.com/WillBooster/tree-sitter-kotlin", tag = "v1.1.0" }
-tree-sitter-javascript = "=0.25.0"
-tree-sitter-python = "=0.21.0"
-tree-sitter-ruby = "=0.21.0"
-# 0.21.0 breaks MSVC (its build script passes the GCC-only -Wno-unused-parameter
-# unconditionally; cl.exe fails with D8021); 0.21.2 gates the flag and the golden-based test
-# suite verifies its grammar changes leave every measured metric unchanged.
-tree-sitter-rust = "=0.21.2"
-tree-sitter-typescript = "=0.21.2"
+# against these grammar versions, so upgrades are deliberate, test-verified changes. The
+# `willbooster-*` crates are WillBooster's forks of the runtime and grammars. Every grammar crate
+# depends only on `tree-sitter-language`, never on upstream's `tree-sitter` crate, whose
+# `links = "tree-sitter"` would conflict with the forked runtime's.
+tree-sitter = { package = "willbooster-tree-sitter", version = "1" }
+tree-sitter-c = { package = "willbooster-tree-sitter-c", version = "=1.1.0" }
+tree-sitter-c-sharp = { package = "willbooster-tree-sitter-c-sharp", version = "=1.0.3" }
+tree-sitter-cpp = { package = "willbooster-tree-sitter-cpp", version = "=1.1.1" }
+tree-sitter-go = "=0.25.0"
+tree-sitter-java = "=0.23.5"
+tree-sitter-javascript = { package = "willbooster-tree-sitter-javascript", version = "=1.0.3" }
+tree-sitter-kotlin = { package = "willbooster-tree-sitter-kotlin", version = "=1.4.0" }
+tree-sitter-python = "=0.25.0"
+tree-sitter-ruby = "=0.23.1"
+tree-sitter-rust = { package = "willbooster-tree-sitter-rust", version = "=1.1.1" }
+tree-sitter-typescript = { package = "willbooster-tree-sitter-typescript", version = "=1.1.1" }
 
 # The WebAssembly build (src/wasm.rs) exports a plain C ABI instead of N-API.
 [target.'cfg(not(target_family = "wasm"))'.dependencies]

package/native/src/dep_degree.rs

@@ -93,7 +93,7 @@ const NON_BINDING_PARAMETER_FIELDS: &[&str] = &["type", "value"];
 /// One leaf of the def-use walk: its field in the parent and its function-scope chain.
 struct DepDegreeLeaf<'t> {
     node: Node<'t>,
-    field_name: Option<&'static str>,
+    field_name: Option<&'t str>,
     /// Chain of nested-function scope ids below the measured function: "" for its own body,
     /// then "/0", "/0/1", ...
     scope: String,
@@ -221,7 +221,7 @@ fn implicit_accessor_definitions<'a>(function_node: Node<'_>, code: &Source<'a>)
 #[allow(clippy::too_many_arguments)]
 fn collect_dep_degree_leaves<'t>(
     node: Node<'t>,
-    field_name: Option<&'static str>,
+    field_name: Option<&'t str>,
     scope: &str,
     next_scope_id: &mut usize,
     function_nodes: &FxHashSet<&'static str>,
@@ -234,7 +234,7 @@ fn collect_dep_degree_leaves<'t>(
     ) {
         return;
     }
-    if node.child_count() == 0 {
+    if crate::util::is_token(node) {
         leaves.push(DepDegreeLeaf {
             node,
             field_name,
@@ -341,7 +341,7 @@ fn is_definition_field(holder: Node<'_>, field_name: Option<&str>) -> bool {
 /// fieldless child; a member pointer's `pointer_type_declarator` is the `name` of a
 /// `qualified_identifier`; an `array_declarator` size or a nested parameter has another field and
 /// stops the climb) to the outermost wrapper and its field in the declaration.
-fn unwrap_declarator_wrappers<'t>(leaf: &DepDegreeLeaf<'t>) -> (Node<'t>, Option<&'static str>) {
+fn unwrap_declarator_wrappers<'t>(leaf: &DepDegreeLeaf<'t>) -> (Node<'t>, Option<&'t str>) {
     let mut current = leaf.node;
     let mut field_name = leaf.field_name;
     while let Some(parent) = current
@@ -439,11 +439,11 @@ fn is_kotlin_parameter(node: Node<'_>) -> bool {
 }
 
 /// Only called with small-arity parents (declarator wrappers, definition-list holders).
-fn field_name_in_parent(node: Node<'_>, parent: Node<'_>) -> Option<&'static str> {
+fn field_name_in_parent<'t>(node: Node<'_>, parent: Node<'t>) -> Option<&'t str> {
     for index in 0..parent.child_count() {
         if let Some(child) = parent.child(index) {
             if child.id() == node.id() {
-                return parent.field_name_for_child(index as u32);
+                return parent.field_name_for_child(index);
             }
         }
     }

package/native/src/duplication.rs

@@ -10,7 +10,7 @@ use crate::types::{
     CrossFileCandidate, CrossFileToken, CrossFileTokenRange, DuplicateBlockOccurrence,
     DuplicationMetrics,
 };
-use crate::util::{all_children, named_children, node_text, to_int32, Source};
+use crate::util::{all_children, is_token, named_children, node_text, to_int32, Source};
 
 /// Block-like nodes considered as whole-subtree duplicate candidates.
 const DUPLICATE_BLOCK_TYPES: &[&str] = &[
@@ -103,6 +103,7 @@ const STATEMENT_CONTAINER_TYPES: &[&str] = &[
     "default_case",
     "compilation_unit",
     "switch_section",
+    "extension_body",
     "enum_class_body",
     "function_body",
     "lambda_literal",
@@ -229,6 +230,8 @@ const STRING_FRAGMENT_TYPES: &[&str] = &[
     "string_literal_content",
     "character_literal_content",
     "raw_string_content",
+    "interpreted_string_literal_content",
+    "raw_string_literal_content",
     "raw_string_start",
     "raw_string_end",
     "escape_sequence",
@@ -292,6 +295,8 @@ const STRING_CONTENT_FRAGMENT_TYPES: &[&str] = &[
     "string_literal_content",
     "character_literal_content",
     "raw_string_content",
+    "interpreted_string_literal_content",
+    "raw_string_literal_content",
     "escape_sequence",
     "heredoc_content",
 ];
@@ -548,20 +553,25 @@ fn collect_tokens<'a>(
     block_ranges: &mut Vec<TokenRange>,
     container_statement_ranges: &mut Vec<Vec<TokenRange>>,
 ) {
+    /// `statement_list_statements` receives the statements of a Go `statement_list`, which wraps
+    /// the statements of blocks and case clauses and whose statements belong to the run of the
+    /// enclosing container.
     fn visit<'a>(
         node: Node<'_>,
         code: &Source<'a>,
         tokens: &mut Vec<Token<'a>>,
         block_ranges: &mut Vec<TokenRange>,
         container_statement_ranges: &mut Vec<Vec<TokenRange>>,
+        statement_list_statements: &mut Vec<TokenRange>,
     ) -> TokenRange {
         let start_token_index = tokens.len();
-        let atomic_kind = if node.child_count() == 0 {
+        let is_token = is_token(node);
+        let atomic_kind = if is_token {
             None
         } else {
             atomic_literal_kind(node)
         };
-        if node.child_count() == 0 {
+        if is_token {
             append_leaf_token(node, code, tokens);
         } else if let Some(atomic_kind) = atomic_kind {
             // Interpolation-free strings collapse to their kind tag so copies differing only in
@@ -575,14 +585,17 @@ fn collect_tokens<'a>(
             ));
         } else if !is_tokenless(node, code) {
             let mut statement_ranges: Vec<TokenRange> = Vec::new();
-            let is_container = is_statement_container(node);
+            let is_statement_list = node.kind_name() == "statement_list";
+            let is_container = is_statement_list || is_statement_container(node);
             for child in all_children(node) {
+                let mut child_statements = Vec::new();
                 let child_range = visit(
                     child,
                     code,
                     tokens,
                     block_ranges,
                     container_statement_ranges,
+                    &mut child_statements,
                 );
                 // A Kotlin lambda's parameters sit beside its statements.
                 if is_container
@@ -590,13 +603,19 @@ fn collect_tokens<'a>(
                     && !is_tokenless(child, code)
                     && child.kind_name() != "lambda_parameters"
                 {
-                    statement_ranges.push(child_range);
+                    if child.kind_name() == "statement_list" {
+                        statement_ranges.append(&mut child_statements);
+                    } else {
+                        statement_ranges.push(child_range);
+                    }
                 }
             }
-            // Single-statement containers are recorded too: window enumeration needs two
-            // statements and yields nothing for them, but cross-file matching catalogues each
-            // container's full run.
-            if is_container && !statement_ranges.is_empty() {
+            if is_statement_list {
+                *statement_list_statements = statement_ranges;
+            } else if is_container && !statement_ranges.is_empty() {
+                // Single-statement containers are recorded too: window enumeration needs two
+                // statements and yields nothing for them, but cross-file matching catalogues each
+                // container's full run.
                 container_statement_ranges.push(statement_ranges);
             }
         }
@@ -615,7 +634,14 @@ fn collect_tokens<'a>(
         range
     }
 
-    visit(root, code, tokens, block_ranges, container_statement_ranges);
+    visit(
+        root,
+        code,
+        tokens,
+        block_ranges,
+        container_statement_ranges,
+        &mut Vec::new(),
+    );
 }
 
 /// Comments and dependency declarations contribute no tokens, so no clone consists of them; the
@@ -935,7 +961,7 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
             .named_child(0)
             .is_some_and(|first| first.id() == node.id());
         let is_last_named = parent
-            .named_child(parent.named_child_count().saturating_sub(1))
+            .named_child(parent.named_child_count().saturating_sub(1) as u32)
             .is_some_and(|last| last.id() == node.id());
         if parent.kind_name() == "navigation_expression" && is_last_named && !is_first_named {
             return true;
@@ -943,7 +969,7 @@ fn is_semantic_name_leaf(node: Node<'_>, code: &Source<'_>) -> bool {
         if parent.kind_name() == "call_expression"
             && is_first_named
             && parent
-                .named_child(parent.named_child_count().saturating_sub(1))
+                .named_child(parent.named_child_count().saturating_sub(1) as u32)
                 .is_some_and(|arguments| {
                     matches!(
                         arguments.kind_name(),

package/native/src/functions.rs

@@ -821,13 +821,16 @@ fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Option<S
     {
         return None;
     }
-    // Go exposes no content node at all: it names only the escapes, so the concatenation is
-    // trusted only when the literal really spells its content out.
+    // Escapes alone do not spell the content out, so the concatenation is trusted only when a
+    // content node takes part in it.
     let mut content = String::new();
     let mut has_content_node = false;
     for child in &children {
         match child.kind_name() {
-            "string_content" | "string_fragment" => {
+            "string_content"
+            | "string_fragment"
+            | "interpreted_string_literal_content"
+            | "raw_string_literal_content" => {
                 has_content_node = true;
                 content.push_str(node_text(*child, code));
             }
@@ -838,8 +841,8 @@ fn find_string_literal_content(literal: Node<'_>, code: &Source<'_>) -> Option<S
     if has_content_node && !content.is_empty() {
         return Some(content);
     }
-    // A grammar that exposes no content child (Go's string literals) keeps its delimiters in the
-    // text; an empty literal is left without a name.
+    // A literal without a content child (Go's rune literal) keeps its delimiters in the text; an
+    // empty literal is left without a name.
     let text = node_text(literal, code);
     let quote = text
         .chars()
@@ -880,7 +883,7 @@ fn find_assignment_target_name(assignment: Node<'_>, code: &Source<'_>) -> Optio
         "field_expression" => target.child_by_field_name("field")?,
         "member_access_expression" => target.child_by_field_name("name")?,
         "field_access" => target.child_by_field_name("field")?,
-        "navigation_expression" => target.named_child(target.named_child_count() - 1)?,
+        "navigation_expression" => target.named_child(target.named_child_count() as u32 - 1)?,
         "qualified_identifier" => return unwrap_declarator_name(Some(target), code),
         _ => return None,
     };
@@ -975,7 +978,7 @@ fn is_value_of_parent(node: Node<'_>, parent: Node<'_>) -> bool {
             .is_some_and(|child| child.id() == node.id())
         {
             return matches!(
-                parent.field_name_for_child(index as u32),
+                parent.field_name_for_child(index),
                 None | Some("value")
             );
         }

package/native/src/languages.rs

@@ -41,24 +41,24 @@ const GRAMMAR_COUNT: usize = GrammarId::Tsx as usize + 1;
 impl LanguageDefinition {
     pub fn grammar(&self) -> Language {
         match self.grammar_id {
-            GrammarId::C => tree_sitter_c::language(),
-            GrammarId::Cpp => tree_sitter_cpp::language(),
-            GrammarId::CSharp => tree_sitter_c_sharp::language(),
-            GrammarId::Go => tree_sitter_go::language(),
-            GrammarId::Java => tree_sitter_java::language(),
+            GrammarId::C => tree_sitter_c::LANGUAGE.into(),
+            GrammarId::Cpp => tree_sitter_cpp::LANGUAGE.into(),
+            GrammarId::CSharp => tree_sitter_c_sharp::LANGUAGE.into(),
+            GrammarId::Go => tree_sitter_go::LANGUAGE.into(),
+            GrammarId::Java => tree_sitter_java::LANGUAGE.into(),
             GrammarId::JavaScript => tree_sitter_javascript::LANGUAGE.into(),
             GrammarId::Kotlin => tree_sitter_kotlin::LANGUAGE.into(),
-            GrammarId::Python => tree_sitter_python::language(),
-            GrammarId::Ruby => tree_sitter_ruby::language(),
-            GrammarId::Rust => tree_sitter_rust::language(),
-            GrammarId::TypeScript => tree_sitter_typescript::language_typescript(),
-            GrammarId::Tsx => tree_sitter_typescript::language_tsx(),
+            GrammarId::Python => tree_sitter_python::LANGUAGE.into(),
+            GrammarId::Ruby => tree_sitter_ruby::LANGUAGE.into(),
+            GrammarId::Rust => tree_sitter_rust::LANGUAGE.into(),
+            GrammarId::TypeScript => tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
+            GrammarId::Tsx => tree_sitter_typescript::LANGUAGE_TSX.into(),
         }
     }
 
     /// The grammar's node kind names, indexed by kind id.
-    pub fn kind_names(&self) -> &'static [&'static str] {
-        static KIND_NAMES: [OnceLock<Vec<&'static str>>; GRAMMAR_COUNT] =
+    pub fn kind_names(&self) -> &'static [String] {
+        static KIND_NAMES: [OnceLock<Vec<String>>; GRAMMAR_COUNT] =
             [const { OnceLock::new() }; GRAMMAR_COUNT];
         KIND_NAMES[self.grammar_id as usize].get_or_init(|| {
             let grammar = self.grammar();
@@ -68,6 +68,7 @@ impl LanguageDefinition {
                         .ok()
                         .and_then(|id| grammar.node_kind_for_id(id))
                         .unwrap_or_default()
+                        .to_string()
                 })
                 .collect()
         })
@@ -361,7 +362,6 @@ const PYTHON_NCSS_NODES: &[&str] = &[
     "for_statement",
     "while_statement",
     "except_clause",
-    "except_group_clause",
     "finally_clause",
     "with_statement",
     "match_statement",
@@ -595,6 +595,7 @@ const CSHARP_NCSS_NODES: &[&str] = &[
     "interface_declaration",
     "enum_declaration",
     "record_declaration",
+    "extension_declaration",
     "delegate_declaration",
     "field_declaration",
     "event_field_declaration",

package/native/src/measure.rs

@@ -16,7 +16,9 @@ use crate::tree_index::{NodeExt, TreeIndex};
 use crate::types::{
     CrossFileFileData, FunctionMetrics, HalsteadCounts, LineMetrics, NativeMetrics,
 };
-use crate::util::{all_children, is_js_whitespace, named_children, node_text, split_lines, Source};
+use crate::util::{
+    all_children, is_js_whitespace, is_token, named_children, node_text, split_lines, Source,
+};
 
 pub fn measure(
     code: &str,
@@ -274,11 +276,11 @@ fn collect_token_symbols(
     ) {
         return;
     }
-    if atomic_operand_node_types().contains(node.kind_name()) {
+    if is_atomic_operand(node) {
         symbols.push(hash_text(node.kind_name()));
         return;
     }
-    if node.child_count() != 0 {
+    if !is_token(node) {
         for child in all_children(node) {
             collect_token_symbols(child, code, symbols, id_index_by_name);
         }
@@ -584,8 +586,6 @@ const OPERAND_NODE_TYPES: &[&str] = &[
     "hex_floating_point_literal",
     "string",
     "string_literal",
-    // Go raw strings are leaves with no content child, unlike Rust/C++ `raw_string_literal`s.
-    "raw_string_literal",
     "verbatim_string_literal",
     "string_fragment",
     "multiline_string_fragment",
@@ -638,7 +638,7 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
     let mut operands: FxHashMap<&str, u64> = FxHashMap::default();
 
     fn visit<'a>(
-        node: Node<'_>,
+        node: Node<'a>,
         code: &Source<'a>,
         operators: &mut FxHashMap<&'a str, u64>,
         operands: &mut FxHashMap<&'a str, u64>,
@@ -650,14 +650,14 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
             return;
         }
 
-        if atomic_operand_node_types().contains(node.kind_name()) {
+        if is_atomic_operand(node) {
             *operands.entry(node_text(node, code)).or_insert(0) += 1;
             return;
         }
 
         // Operators are counted from leaf tokens only: keyword-named nodes always contain a
         // same-text anonymous keyword leaf, so counting the named node as well would double-count.
-        if node.child_count() == 0 {
+        if is_token(node) {
             let text = node_text(node, code);
             // Operands win over text matches so identifiers spelled like word operators stay operands;
             // C# `nameof(x)` is the one keyword operator the grammar parses as a plain callee.
@@ -694,6 +694,14 @@ fn measure_halstead(root: Node<'_>, code: &Source<'_>) -> HalsteadCounts {
     }
 }
 
+/// A literal counted as one operand without descending: ATOMIC_OPERAND_NODE_TYPES, or a Go raw
+/// string, which wraps its content like Go's interpreted strings (the Rust and C++
+/// `raw_string_literal`s count their content leaves instead).
+fn is_atomic_operand(node: Node<'_>) -> bool {
+    atomic_operand_node_types().contains(node.kind_name())
+        || (node.kind_name() == "raw_string_literal" && crate::tree_index::language_name() == "go")
+}
+
 /// tree-sitter-c-sharp parses `nameof(x)` as an invocation of an identifier named `nameof`.
 fn is_csharp_nameof_callee(node: Node<'_>, text: &str) -> bool {
     text == "nameof"

package/native/src/tree_index.rs

@@ -11,7 +11,7 @@ thread_local! {
     /// nodes; TreeIndex borrows the tree and clears the map on drop, so no entry outlives it.
     static PARENTS: RefCell<FxHashMap<usize, Node<'static>>> = RefCell::new(FxHashMap::default());
     /// Node kind names of the indexed tree's language, indexed by kind id.
-    static KIND_NAMES: Cell<&'static [&'static str]> = const { Cell::new(&[]) };
+    static KIND_NAMES: Cell<&'static [String]> = const { Cell::new(&[]) };
     /// Name of the indexed tree's language.
     static LANGUAGE_NAME: Cell<&'static str> = const { Cell::new("") };
 }
@@ -87,7 +87,7 @@ pub trait NodeExt<'t> {
     /// `Node::parent`, answered from the TreeIndex when one is installed.
     fn parent_node(self) -> Option<Node<'t>>;
     /// `Node::kind`, answered from the TreeIndex when one is installed.
-    fn kind_name(self) -> &'static str;
+    fn kind_name(self) -> &'t str;
 }
 
 impl<'t> NodeExt<'t> for Node<'t> {
@@ -109,11 +109,11 @@ impl<'t> NodeExt<'t> for Node<'t> {
             .or_else(|| self.parent())
     }
 
-    fn kind_name(self) -> &'static str {
+    fn kind_name(self) -> &'t str {
         KIND_NAMES
             .get()
             .get(usize::from(self.kind_id()))
-            .copied()
+            .map(String::as_str)
             .unwrap_or_else(|| self.kind())
     }
 }

package/native/src/util.rs

@@ -61,6 +61,13 @@ pub fn is_kotlin_keyword_literal(node: Node<'_>, code: &Source<'_>) -> bool {
         && matches!(node_text(node, code), "true" | "false" | "null")
 }
 
+/// Whether the node stands for one source token. C# spells a contextual keyword used as a name
+/// (`type`, `field`, `alias`) as an `identifier` or `implicit_parameter` wrapping the keyword token,
+/// which still names a variable like any other identifier.
+pub fn is_token(node: Node<'_>) -> bool {
+    node.child_count() == 0 || matches!(node.kind_name(), "identifier" | "implicit_parameter")
+}
+
 pub fn named_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
     let mut cursor = node.walk();
     node.named_children(&mut cursor).collect()
@@ -77,13 +84,13 @@ pub fn all_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
 /// them), which would desynchronize field-based extraction on malformed source.
 pub fn find_children_by_field_name<'t>(node: Node<'t>, field_name: &str) -> Vec<Node<'t>> {
     let mut children = Vec::new();
-    let mut preceding_structural_field: Option<&'static str> = None;
+    let mut preceding_structural_field = None;
     for index in 0..node.child_count() {
         if let Some(child) = node.child(index) {
             let field = if child.is_extra() {
                 preceding_structural_field
             } else {
-                let field = node.field_name_for_child(index as u32);
+                let field = node.field_name_for_child(index);
                 preceding_structural_field = field;
                 field
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -62,6 +62,7 @@
     "verify-full": "bun wb verify --full"
   },
   "dependencies": {
+    "@willbooster/shared-lib": "10.18.0",
     "commander": "15.0.0"
   },
   "devDependencies": {
@@ -94,12 +95,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "5.0.0",
-    "code-gauge-linux-arm64-gnu": "5.0.0",
-    "code-gauge-linux-x64-musl": "5.0.0",
-    "code-gauge-linux-arm64-musl": "5.0.0",
-    "code-gauge-darwin-x64": "5.0.0",
-    "code-gauge-darwin-arm64": "5.0.0",
-    "code-gauge-win32-x64-msvc": "5.0.0"
+    "code-gauge-linux-x64-gnu": "5.1.0",
+    "code-gauge-linux-arm64-gnu": "5.1.0",
+    "code-gauge-linux-x64-musl": "5.1.0",
+    "code-gauge-linux-arm64-musl": "5.1.0",
+    "code-gauge-darwin-x64": "5.1.0",
+    "code-gauge-darwin-arm64": "5.1.0",
+    "code-gauge-win32-x64-msvc": "5.1.0"
   }
 }