@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/cameligo.json

@@ -0,0 +1,147 @@
+{
+  "language": "cameligo",
+  "definitions": {
+    "int": {
+      "signature": "type int",
+      "description": "A signed integer type in CameLIGO used for representing positive and negative whole numbers on the Tezos blockchain. Integer arithmetic is unbounded (arbitrary precision) and supports addition, subtraction, multiplication, and Euclidean division.",
+      "type": "class",
+      "module": "LIGO.Stdlib",
+      "members": {
+        "abs": {
+          "signature": "abs(i: int) -> nat",
+          "description": "Returns the absolute value of the integer as a natural number (nat type).",
+          "type": "function"
+        },
+        "is_nat": {
+          "signature": "is_nat(i: int) -> option<nat>",
+          "description": "Converts an integer to a natural number, returning Some(n) if non-negative or None if negative.",
+          "type": "function"
+        },
+        "int": {
+          "signature": "int(n: nat) -> int",
+          "description": "Converts a natural number (nat) to a signed integer value.",
+          "type": "function"
+        }
+      }
+    },
+    "string": {
+      "signature": "type string",
+      "description": "The string type in CameLIGO represents immutable sequences of characters. Strings support concatenation with the ^ operator and can be sliced to extract substrings. String operations are commonly used in error messages, metadata, and entrypoint annotations on Tezos smart contracts.",
+      "type": "class",
+      "module": "LIGO.Stdlib",
+      "members": {
+        "String.length": {
+          "signature": "String.length(s: string) -> nat",
+          "description": "Returns the length of the string in characters as a natural number.",
+          "type": "function"
+        },
+        "String.concat": {
+          "signature": "String.concat(s1: string, s2: string) -> string",
+          "description": "Concatenates two strings together, producing a new string with s1 followed by s2.",
+          "type": "function"
+        },
+        "String.sub": {
+          "signature": "String.sub(offset: nat, length: nat, s: string) -> string",
+          "description": "Extracts a substring from the string starting at the given offset with the specified length.",
+          "type": "function"
+        }
+      }
+    },
+    "nat": {
+      "signature": "type nat",
+      "description": "A natural number (non-negative integer) type in CameLIGO, representing zero and positive whole numbers. Natural numbers are essential in Tezos smart contracts for representing quantities like token amounts, counters, and sizes. Literal values use the 'n' suffix (e.g., 42n).",
+      "type": "class",
+      "module": "LIGO.Stdlib"
+    },
+    "tez": {
+      "signature": "type tez",
+      "description": "The tez type represents amounts of the Tezos native cryptocurrency (XTZ) in mutez (micro-tez, 1 tez = 1,000,000 mutez). Tez values are used for transfers, balance checks, and specifying amounts in smart contract operations. Literal values use the 'tez' or 'mutez' suffix.",
+      "type": "class",
+      "module": "LIGO.Stdlib"
+    },
+    "address": {
+      "signature": "type address",
+      "description": "The address type represents a Tezos account address, which can be either an implicit account (tz1, tz2, tz3 prefixed) or a smart contract address (KT1 prefixed). Addresses are used for identifying senders, receivers, and contract targets in on-chain operations.",
+      "type": "class",
+      "module": "LIGO.Stdlib"
+    },
+    "map": {
+      "signature": "type ('key, 'value) map",
+      "description": "An immutable ordered key-value mapping in CameLIGO that associates keys to values. Maps use balanced binary trees and support efficient lookup, insertion, and removal. For larger datasets in contracts, big_map should be used instead to reduce gas costs.",
+      "type": "class",
+      "module": "LIGO.Stdlib",
+      "members": {
+        "Map.empty": {
+          "signature": "Map.empty : ('k, 'v) map",
+          "description": "Creates a new empty map with no key-value bindings.",
+          "type": "function"
+        },
+        "Map.add": {
+          "signature": "Map.add(key: 'k, value: 'v, m: ('k, 'v) map) -> ('k, 'v) map",
+          "description": "Returns a new map with the binding of key to value added or updated, leaving the original unchanged.",
+          "type": "function"
+        },
+        "Map.remove": {
+          "signature": "Map.remove(key: 'k, m: ('k, 'v) map) -> ('k, 'v) map",
+          "description": "Returns a new map with the binding for the specified key removed, if it exists.",
+          "type": "function"
+        },
+        "Map.find_opt": {
+          "signature": "Map.find_opt(key: 'k, m: ('k, 'v) map) -> option<'v>",
+          "description": "Looks up a key in the map, returning Some(value) if found or None if the key is not present.",
+          "type": "function"
+        },
+        "Map.mem": {
+          "signature": "Map.mem(key: 'k, m: ('k, 'v) map) -> bool",
+          "description": "Returns true if the specified key exists in the map, false otherwise.",
+          "type": "function"
+        },
+        "Map.fold": {
+          "signature": "Map.fold(f: ('acc * ('k * 'v)) -> 'acc, m: ('k, 'v) map, init: 'acc) -> 'acc",
+          "description": "Folds over all key-value pairs in the map, accumulating a result from left to right starting with the initial value.",
+          "type": "function"
+        }
+      }
+    },
+    "list": {
+      "signature": "type 'a list",
+      "description": "An immutable singly-linked list in CameLIGO that supports pattern matching and functional operations. Lists are constructed with the cons operator (::) and the empty list ([]) and are the primary sequential data structure for Tezos smart contracts.",
+      "type": "class",
+      "module": "LIGO.Stdlib",
+      "members": {
+        "List.length": {
+          "signature": "List.length(l: 'a list) -> nat",
+          "description": "Returns the number of elements in the list as a natural number.",
+          "type": "function"
+        },
+        "List.map": {
+          "signature": "List.map(f: 'a -> 'b, l: 'a list) -> 'b list",
+          "description": "Applies a function to each element of the list and returns a new list with the transformed values.",
+          "type": "function"
+        },
+        "List.iter": {
+          "signature": "List.iter(f: 'a -> unit, l: 'a list) -> unit",
+          "description": "Applies a function to each element of the list in order for its side effects only.",
+          "type": "function"
+        },
+        "List.fold": {
+          "signature": "List.fold(f: ('acc * 'a) -> 'acc, l: 'a list, init: 'acc) -> 'acc",
+          "description": "Folds over the list elements from left to right, threading an accumulator through each application.",
+          "type": "function"
+        }
+      }
+    },
+    "option": {
+      "signature": "type 'a option = Some of 'a | None",
+      "description": "A variant type representing an optional value that may or may not be present. Some(value) wraps a present value while None indicates absence. Option types are pervasive in CameLIGO for safe handling of map lookups and operations that may fail.",
+      "type": "class",
+      "module": "LIGO.Stdlib"
+    },
+    "unit": {
+      "signature": "type unit",
+      "description": "A type with a single value, written as (), representing no meaningful information. Unit is used as the return type for side-effect functions and as the parameter type for entrypoints that take no arguments in Tezos smart contracts.",
+      "type": "class",
+      "module": "LIGO.Stdlib"
+    }
+  }
+}

package/data/definition/clojure.json

@@ -0,0 +1,92 @@
+{
+  "language": "clojure",
+  "definitions": {
+    "defn": {
+      "signature": "(defn name [params*] body)",
+      "description": "Defines a named function in the current namespace. The first argument is the function name, followed by an optional docstring, a vector of parameter bindings, and the function body. Supports multi-arity definitions with multiple parameter vectors and bodies wrapped in parentheses.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "def": {
+      "signature": "(def name value)",
+      "description": "Creates a global Var in the current namespace bound to the given value. Vars are the primary mechanism for defining top-level bindings. Re-evaluating def replaces the root binding, which is visible to all threads unless thread-local bindings exist.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "let": {
+      "signature": "(let [bindings*] body)",
+      "description": "Creates local bindings in a lexical scope. Takes a vector of binding pairs (name value) and a body of expressions. Bindings are sequential—later bindings can reference earlier ones. The value of the last expression in the body is returned.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "fn": {
+      "signature": "(fn [params*] body)",
+      "description": "Creates an anonymous (lambda) function. Takes a vector of parameters and a body of expressions. Supports multi-arity definitions and can optionally include a name for self-reference in recursive calls. Used extensively for callbacks, map functions, and closures.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "map": {
+      "signature": "(map f coll) -> lazy-seq",
+      "description": "Returns a lazy sequence consisting of the result of applying function f to each item in the collection. When passed multiple collections, applies f to corresponding items from each, stopping when the shortest collection is exhausted. One of the most fundamental higher-order functions in Clojure.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "filter": {
+      "signature": "(filter pred coll) -> lazy-seq",
+      "description": "Returns a lazy sequence of the items in the collection for which the predicate function returns a logically true value. Items for which the predicate returns nil or false are excluded from the result. Can also be used as a transducer when called with only a predicate.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "reduce": {
+      "signature": "(reduce f init coll) -> value",
+      "description": "Reduces the collection to a single value by repeatedly applying function f to an accumulator and each element. If init is supplied, it serves as the initial accumulator; otherwise the first two elements are used. Returns the final accumulated value after processing all elements.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "atom": {
+      "signature": "(atom x) -> Atom",
+      "description": "Creates an Atom, a thread-safe mutable reference type that provides synchronous, uncoordinated, independent state management. Atoms ensure atomic updates via compare-and-swap semantics and are the primary way to manage shared mutable state in Clojure programs.",
+      "type": "function",
+      "module": "clojure.core",
+      "members": {
+        "deref": {
+          "signature": "(deref atom) or @atom -> value",
+          "description": "Returns the current value held by the atom without blocking or modifying it.",
+          "type": "function"
+        },
+        "swap!": {
+          "signature": "(swap! atom f args*) -> new-value",
+          "description": "Atomically updates the atom's value by applying function f to the current value and any additional args, retrying if another thread modified it concurrently.",
+          "type": "function"
+        },
+        "reset!": {
+          "signature": "(reset! atom new-value) -> new-value",
+          "description": "Sets the atom's value to new-value without regard to the current value, returning the new value.",
+          "type": "function"
+        },
+        "compare-and-set!": {
+          "signature": "(compare-and-set! atom oldval newval) -> boolean",
+          "description": "Atomically sets the atom to newval if and only if the current value is identical to oldval, returning true on success.",
+          "type": "function"
+        },
+        "add-watch": {
+          "signature": "(add-watch atom key fn) -> atom",
+          "description": "Adds a watch function that is called whenever the atom's value changes, receiving the key, atom, old value, and new value.",
+          "type": "function"
+        }
+      }
+    },
+    "str": {
+      "signature": "(str x & ys) -> String",
+      "description": "Coerces its arguments to strings and concatenates them. With no args returns the empty string. With one arg, returns its toString value. With multiple args, returns the concatenation of all toString values. nil arguments are treated as empty strings.",
+      "type": "function",
+      "module": "clojure.core"
+    },
+    "println": {
+      "signature": "(println & args) -> nil",
+      "description": "Prints the string representation of each argument separated by spaces, followed by a newline, to the current value of *out* (typically standard output). Uses pr-str for string conversion, which prints strings without surrounding quotes.",
+      "type": "function",
+      "module": "clojure.core"
+    }
+  }
+}

package/data/definition/coffee.json

@@ -0,0 +1,192 @@
+{
+  "language": "coffee",
+  "definitions": {
+    "Array": {
+      "signature": "class Array",
+      "description": "The built-in Array type in CoffeeScript (inherited from JavaScript) represents an ordered, integer-indexed collection of values. Arrays are dynamically sized and can hold mixed types. CoffeeScript adds syntactic sugar like list comprehensions, splats, and range-based slicing.",
+      "type": "class",
+      "module": "Global",
+      "members": {
+        "push": {
+          "signature": "array.push(element...) -> Number",
+          "description": "Appends one or more elements to the end of the array and returns the new length.",
+          "type": "method"
+        },
+        "pop": {
+          "signature": "array.pop() -> element",
+          "description": "Removes the last element from the array and returns it, or undefined if the array is empty.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "array.map(callback) -> Array",
+          "description": "Creates a new array with the results of calling the callback function on every element of the array.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "array.filter(callback) -> Array",
+          "description": "Creates a new array with all elements that pass the test implemented by the callback function.",
+          "type": "method"
+        },
+        "reduce": {
+          "signature": "array.reduce(callback, initialValue?) -> value",
+          "description": "Applies a function against an accumulator and each element to reduce the array to a single value.",
+          "type": "method"
+        },
+        "slice": {
+          "signature": "array.slice(begin?, end?) -> Array",
+          "description": "Returns a shallow copy of a portion of the array into a new array, selected from begin to end (exclusive).",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "array.forEach(callback) -> undefined",
+          "description": "Executes a provided function once for each array element in ascending index order.",
+          "type": "method"
+        }
+      }
+    },
+    "Object": {
+      "signature": "class Object",
+      "description": "The base prototype for all CoffeeScript/JavaScript objects, providing key-value storage and prototype-based inheritance. Objects are used as hash maps, configuration containers, and the foundation for class instances. CoffeeScript supports object literals with implicit braces and significant indentation.",
+      "type": "class",
+      "module": "Global",
+      "members": {
+        "keys": {
+          "signature": "Object.keys(obj) -> Array<String>",
+          "description": "Returns an array of the object's own enumerable string-keyed property names.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "Object.values(obj) -> Array",
+          "description": "Returns an array of the object's own enumerable property values.",
+          "type": "method"
+        },
+        "assign": {
+          "signature": "Object.assign(target, ...sources) -> Object",
+          "description": "Copies all own enumerable properties from one or more source objects to a target object and returns the target.",
+          "type": "method"
+        },
+        "hasOwnProperty": {
+          "signature": "obj.hasOwnProperty(prop) -> Boolean",
+          "description": "Returns true if the object has the specified property as its own (non-inherited) property.",
+          "type": "method"
+        },
+        "freeze": {
+          "signature": "Object.freeze(obj) -> Object",
+          "description": "Freezes an object so that no new properties can be added and existing properties cannot be modified or deleted.",
+          "type": "method"
+        }
+      }
+    },
+    "String": {
+      "signature": "class String",
+      "description": "The built-in String type representing a sequence of UTF-16 characters. CoffeeScript supports string interpolation with double-quoted strings using #{expression} syntax, heredoc strings with triple quotes for multi-line text, and block strings that preserve indentation.",
+      "type": "class",
+      "module": "Global",
+      "members": {
+        "split": {
+          "signature": "str.split(separator, limit?) -> Array<String>",
+          "description": "Divides the string into an array of substrings by splitting at each occurrence of the separator.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "str.replace(pattern, replacement) -> String",
+          "description": "Returns a new string with the first (or all, with global regex) match of pattern replaced by replacement.",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "str.indexOf(searchValue, fromIndex?) -> Number",
+          "description": "Returns the index of the first occurrence of the search value, or -1 if not found.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "str.trim() -> String",
+          "description": "Returns a new string with whitespace removed from both ends of the string.",
+          "type": "method"
+        },
+        "toUpperCase": {
+          "signature": "str.toUpperCase() -> String",
+          "description": "Returns the string converted to uppercase letters according to locale-independent Unicode mappings.",
+          "type": "method"
+        }
+      }
+    },
+    "console": {
+      "signature": "console: Object",
+      "description": "The console object provides access to the browser or Node.js debugging console for outputting messages, warnings, errors, and performance timing information. It is the primary tool for runtime debugging and logging in CoffeeScript applications.",
+      "type": "module",
+      "module": "Global",
+      "members": {
+        "log": {
+          "signature": "console.log(data...) -> undefined",
+          "description": "Outputs the arguments to the console with a newline, supporting string substitution and multiple arguments.",
+          "type": "method"
+        },
+        "error": {
+          "signature": "console.error(data...) -> undefined",
+          "description": "Outputs an error message to the console, typically displayed in red with a stack trace in browsers.",
+          "type": "method"
+        },
+        "warn": {
+          "signature": "console.warn(data...) -> undefined",
+          "description": "Outputs a warning message to the console, typically displayed with a yellow icon in browsers.",
+          "type": "method"
+        },
+        "time": {
+          "signature": "console.time(label) -> undefined",
+          "description": "Starts a timer with the given label name for measuring execution duration of code blocks.",
+          "type": "method"
+        },
+        "timeEnd": {
+          "signature": "console.timeEnd(label) -> undefined",
+          "description": "Stops the timer with the given label and outputs the elapsed time in milliseconds to the console.",
+          "type": "method"
+        }
+      }
+    },
+    "Math": {
+      "signature": "Math: Object",
+      "description": "The Math object provides standard mathematical constants (PI, E, LN2, etc.) and static functions for common mathematical operations including trigonometry, rounding, random number generation, exponentiation, and finding minimum/maximum values.",
+      "type": "module",
+      "module": "Global",
+      "members": {
+        "floor": {
+          "signature": "Math.floor(x) -> Number",
+          "description": "Returns the largest integer less than or equal to a given number (rounds down).",
+          "type": "method"
+        },
+        "ceil": {
+          "signature": "Math.ceil(x) -> Number",
+          "description": "Returns the smallest integer greater than or equal to a given number (rounds up).",
+          "type": "method"
+        },
+        "random": {
+          "signature": "Math.random() -> Number",
+          "description": "Returns a pseudo-random floating-point number between 0 (inclusive) and 1 (exclusive).",
+          "type": "method"
+        },
+        "max": {
+          "signature": "Math.max(value1, value2, ...values) -> Number",
+          "description": "Returns the largest of the given numbers, or -Infinity if no arguments are provided.",
+          "type": "method"
+        },
+        "min": {
+          "signature": "Math.min(value1, value2, ...values) -> Number",
+          "description": "Returns the smallest of the given numbers, or Infinity if no arguments are provided.",
+          "type": "method"
+        }
+      }
+    },
+    "require": {
+      "signature": "require(module: String) -> module.exports",
+      "description": "Imports a module in CoffeeScript (Node.js CommonJS modules). Takes a module identifier string which can be a core module name, a relative file path, or an npm package name. Returns the exported object or value from the module, enabling code reuse and dependency management.",
+      "type": "function",
+      "module": "Node.js"
+    },
+    "class": {
+      "signature": "class ClassName [extends ParentClass]",
+      "description": "Declares a class in CoffeeScript with optional inheritance using 'extends'. CoffeeScript classes compile to JavaScript prototypal inheritance and support a constructor method, instance methods, static methods (prefixed with @), and the super keyword for calling parent class methods. Class bodies use significant indentation.",
+      "type": "keyword",
+      "module": "CoffeeScript"
+    }
+  }
+}

package/data/definition/cypher.json

@@ -0,0 +1,105 @@
+{
+  "language": "cypher",
+  "definitions": {
+    "MATCH": {
+      "signature": "MATCH (pattern) [WHERE condition] RETURN expression",
+      "description": "The primary read clause in Cypher for finding graph patterns in Neo4j. MATCH specifies node and relationship patterns using ASCII art syntax — (node)-[rel]->(node) — and binds matched elements to variables. Supports variable-length paths, optional matches, and complex traversal patterns.",
+      "type": "keyword",
+      "module": "Cypher Reading",
+      "members": {
+        "OPTIONAL MATCH": {
+          "signature": "OPTIONAL MATCH (pattern)",
+          "description": "Matches a pattern like MATCH but returns null for missing parts instead of filtering out rows, similar to an outer join in SQL.",
+          "type": "clause"
+        },
+        "WHERE": {
+          "signature": "WHERE predicate",
+          "description": "Filters the matched patterns to only include rows where the Boolean predicate evaluates to true, supporting property comparisons, existence checks, and regex.",
+          "type": "clause"
+        }
+      }
+    },
+    "CREATE": {
+      "signature": "CREATE (n:Label {prop: value})-[:REL_TYPE]->(m:Label {prop: value})",
+      "description": "Creates new nodes and relationships in the Neo4j graph database. Each node can have labels (like types) and properties (key-value pairs). Relationships connect two nodes with a type and optional properties. CREATE always creates new elements and never reuses existing ones.",
+      "type": "keyword",
+      "module": "Cypher Writing"
+    },
+    "MERGE": {
+      "signature": "MERGE (n:Label {key: value}) [ON CREATE SET ...] [ON MATCH SET ...]",
+      "description": "Ensures a pattern exists in the graph by either matching an existing element or creating a new one if no match is found. MERGE is an idempotent operation that prevents duplicate nodes and relationships, with optional ON CREATE and ON MATCH clauses for conditional property setting.",
+      "type": "keyword",
+      "module": "Cypher Writing",
+      "members": {
+        "ON CREATE SET": {
+          "signature": "ON CREATE SET n.property = value",
+          "description": "Sets properties only when MERGE creates a new node or relationship, not when it matches an existing one.",
+          "type": "clause"
+        },
+        "ON MATCH SET": {
+          "signature": "ON MATCH SET n.property = value",
+          "description": "Sets properties only when MERGE matches an existing node or relationship, not when it creates a new one.",
+          "type": "clause"
+        }
+      }
+    },
+    "SET": {
+      "signature": "SET n.property = value | SET n:Label | SET n += {props}",
+      "description": "Updates properties on nodes and relationships or adds labels to nodes. SET can assign a single property, add a label, or merge a map of properties. Using += merges properties (preserving existing ones), while = replaces all properties.",
+      "type": "keyword",
+      "module": "Cypher Writing"
+    },
+    "DELETE": {
+      "signature": "DELETE node | DETACH DELETE node",
+      "description": "Removes nodes and relationships from the graph. Plain DELETE can only remove nodes with no relationships; DETACH DELETE automatically removes all connected relationships before deleting the node. Deleting a relationship does not affect its connected nodes.",
+      "type": "keyword",
+      "module": "Cypher Writing"
+    },
+    "RETURN": {
+      "signature": "RETURN expression [AS alias] [ORDER BY field] [SKIP n] [LIMIT n]",
+      "description": "Defines what data to return from a Cypher query. Can return nodes, relationships, properties, aggregations, or computed values. Supports aliasing with AS, ordering with ORDER BY, pagination with SKIP and LIMIT, and DISTINCT for unique results.",
+      "type": "keyword",
+      "module": "Cypher Reading",
+      "members": {
+        "ORDER BY": {
+          "signature": "ORDER BY expression [ASC|DESC]",
+          "description": "Sorts the result rows by one or more expressions in ascending (default) or descending order.",
+          "type": "clause"
+        },
+        "LIMIT": {
+          "signature": "LIMIT count",
+          "description": "Constrains the number of result rows returned, useful for pagination and top-N queries.",
+          "type": "clause"
+        },
+        "SKIP": {
+          "signature": "SKIP count",
+          "description": "Skips the specified number of result rows, used in combination with LIMIT for pagination.",
+          "type": "clause"
+        },
+        "DISTINCT": {
+          "signature": "RETURN DISTINCT expression",
+          "description": "Removes duplicate rows from the result set based on the returned expressions.",
+          "type": "clause"
+        }
+      }
+    },
+    "WITH": {
+      "signature": "WITH expression [AS alias] [WHERE condition]",
+      "description": "Chains query parts together by passing results from one part to the next, acting as both a projection and a pipeline separator. WITH allows intermediate filtering, aggregation, and variable scoping within a single Cypher query, similar to a subquery boundary.",
+      "type": "keyword",
+      "module": "Cypher Reading"
+    },
+    "WHERE": {
+      "signature": "WHERE predicate",
+      "description": "Filters results to only include rows where the Boolean predicate is true. Supports property comparisons (=, <>, <, >), string matching (STARTS WITH, ENDS WITH, CONTAINS), regular expressions (=~), NULL checks (IS NULL, IS NOT NULL), list predicates, and path existence patterns.",
+      "type": "keyword",
+      "module": "Cypher Reading"
+    },
+    "UNWIND": {
+      "signature": "UNWIND list AS variable",
+      "description": "Expands a list into individual rows, one per element. UNWIND is essential for processing collections passed as parameters, transforming list properties into rows for further matching or creation, and implementing batch operations in Cypher queries.",
+      "type": "keyword",
+      "module": "Cypher Reading"
+    }
+  }
+}