IncludeCPP 3.7.4__py3-none-any.whl → 3.7.6__py3-none-any.whl

includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.7.4"
+__version__ = "3.7.6"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/cli/commands.py

@@ -7480,13 +7480,12 @@ def cssl_exec(path, code):
     # Execute
     click.secho("--- Output ---", fg='green')
     try:
-        result = cssl_lang.exec(source)
+        result = cssl_lang.run(source)
 
         # Output is already printed to stdout during execution via runtime.output()
-        # No need to print buffer again - this was causing double output
-
-        if result is not None:
-            click.echo(f"Result: {result}")
+        # Don't print "Result:" automatically - users should use printl() for output
+        # This prevents unwanted output for function calls like: Function();
+        pass
 
     except Exception as e:
         click.secho(f"CSSL Error: {e}", fg='red')
@@ -7595,75 +7594,95 @@ def cssl_doc(search, list_sections):
             click.secho("=" * 50, fg='cyan')
             click.echo()
 
-            # Split into sections (## headers)
-            sections = re.split(r'(?=^## )', content, flags=re.MULTILINE)
-
-            found_sections = []
-            for section in sections:
-                if search.lower() in section.lower():
-                    found_sections.append(section)
-
-            if found_sections:
-                # Also find specific lines with the search term
-                all_lines = content.split('\n')
-                matching_lines = []
-                for i, line in enumerate(all_lines):
-                    if search.lower() in line.lower():
-                        # Get context (2 lines before and after)
-                        start = max(0, i - 2)
-                        end = min(len(all_lines), i + 3)
-                        context = '\n'.join(all_lines[start:end])
-                        if context not in matching_lines:
-                            matching_lines.append((i + 1, context))
-
-                # Show summary
-                click.secho(f"Found in {len(found_sections)} section(s):", fg='green')
-                for section in found_sections:
-                    # Extract section title
-                    title_match = re.match(r'^##\s+(.+)$', section, re.MULTILINE)
-                    if title_match:
-                        click.echo(f"  - {title_match.group(1)}")
+            # Split into subsections (### headers) for focused results
+            subsections = re.split(r'(?=^### )', content, flags=re.MULTILINE)
 
-                click.echo()
+            # Also split into main sections (## headers)
+            main_sections = re.split(r'(?=^## )', content, flags=re.MULTILINE)
 
-                # Show matching contexts with highlighting
-                click.secho("Matching content:", fg='yellow', bold=True)
-                click.secho("-" * 50, fg='yellow')
+            # Find matching subsections (### level) - most focused
+            matching_subsections = []
+            for subsection in subsections:
+                if search.lower() in subsection.lower():
+                    # Extract title
+                    title_match = re.match(r'^###\s+(.+)$', subsection, re.MULTILINE)
+                    if title_match:
+                        # Trim subsection to just the content until next ### or ##
+                        lines = subsection.split('\n')
+                        trimmed_lines = []
+                        for line in lines:
+                            if line.startswith('## ') and not line.startswith('### '):
+                                break
+                            trimmed_lines.append(line)
+                        matching_subsections.append((title_match.group(1), '\n'.join(trimmed_lines)))
+
+            if matching_subsections:
+                click.secho(f"Found {len(matching_subsections)} matching subsection(s):", fg='green')
+                click.echo()
 
-                for line_num, context in matching_lines[:15]:  # Limit to 15 matches
-                    click.echo(f"\nLine {line_num}:")
-                    # Highlight the search term
+                # Show focused subsections (limit output)
+                for title, sub_content in matching_subsections[:5]:
+                    click.secho(f"### {title}", fg='yellow', bold=True)
+                    # Highlight search term in content
                     highlighted = re.sub(
                         f'({re.escape(search)})',
                         click.style(r'\1', fg='green', bold=True),
-                        context,
+                        sub_content,
                         flags=re.IGNORECASE
                     )
-                    click.echo(highlighted)
-                    click.echo("-" * 30)
-
-                if len(matching_lines) > 15:
-                    click.echo(f"\n... and {len(matching_lines) - 15} more matches")
-
-                # Offer to show full sections
-                click.echo()
-                click.secho("Full sections containing your search:", fg='cyan')
-                click.echo("(Scroll or pipe to a file for full content)")
-                click.echo()
-
-                for section in found_sections:
-                    click.echo(section)
+                    # Limit lines per subsection
+                    lines = highlighted.split('\n')
+                    if len(lines) > 30:
+                        click.echo('\n'.join(lines[:30]))
+                        click.secho(f"  ... ({len(lines) - 30} more lines)", fg='cyan')
+                    else:
+                        click.echo(highlighted)
+                    click.echo()
+                    click.secho("-" * 40, fg='cyan')
                     click.echo()
 
+                if len(matching_subsections) > 5:
+                    click.secho(f"... and {len(matching_subsections) - 5} more subsections", fg='cyan')
+                    click.echo("Use --list to see all sections")
             else:
-                click.secho(f"No matches found for '{search}'", fg='yellow')
-                click.echo()
-                click.echo("Try searching for:")
-                click.echo("  - Keywords: class, function, define, open, global")
-                click.echo("  - Syntax: $, @, ::, this->, <<==, <==")
-                click.echo("  - Types: string, int, stack, vector, map, json")
-                click.echo()
-                click.echo("Or use: includecpp cssl doc --list")
+                # Fall back to main section search (## level)
+                found_sections = []
+                for section in main_sections:
+                    if search.lower() in section.lower():
+                        title_match = re.match(r'^##\s+(.+)$', section, re.MULTILINE)
+                        if title_match:
+                            found_sections.append((title_match.group(1), section))
+
+                if found_sections:
+                    click.secho(f"Found in {len(found_sections)} section(s):", fg='green')
+                    for title, _ in found_sections:
+                        click.echo(f"  - {title}")
+                    click.echo()
+
+                    # Show first matching section, trimmed
+                    title, section = found_sections[0]
+                    click.secho(f"## {title}", fg='yellow', bold=True)
+                    highlighted = re.sub(
+                        f'({re.escape(search)})',
+                        click.style(r'\1', fg='green', bold=True),
+                        section,
+                        flags=re.IGNORECASE
+                    )
+                    lines = highlighted.split('\n')
+                    if len(lines) > 40:
+                        click.echo('\n'.join(lines[:40]))
+                        click.secho(f"\n... ({len(lines) - 40} more lines in this section)", fg='cyan')
+                    else:
+                        click.echo(highlighted)
+                else:
+                    click.secho(f"No matches found for '{search}'", fg='yellow')
+                    click.echo()
+                    click.echo("Try searching for:")
+                    click.echo("  - Keywords: class, function, define, open, global, shuffled")
+                    click.echo("  - Syntax: $, @, ::, this->, <<==, <==, #$")
+                    click.echo("  - Types: string, int, stack, vector, map, json")
+                    click.echo()
+                    click.echo("Or use: includecpp cssl doc --list")
         else:
             # Full documentation mode
             click.echo_via_pager(content)

includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.7.2 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.7.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
 
 ---
 
@@ -41,22 +41,25 @@
 ```python
 from includecpp import CSSL
 
-# Initialize CSSL
-CSSL.CsslLang()
-
-# Execute code
-CSSL.exec("""
+# Execute code (v3.7.6+: use run() instead of exec())
+CSSL.run("""
     printl("Hello CSSL!");
 """)
 
 # With parameters and return value
-result = CSSL.exec("""
+result = CSSL.run("""
     string name = parameter.get(0);
     printl("Hello " + name);
     parameter.return(true);
 """, "World")
 
 print(result)  # True
+
+# Create typed scripts and modules (v3.7.6+)
+main = CSSL.script("cssl", '''printl("Main");''')
+payload = CSSL.script("cssl-pl", '''void helper() { printl("Helper!"); }''')
+mod = CSSL.makemodule(main, payload, "mymod")
+mod.helper()  # Call function directly
 ```
 
 ### CLI Execution
@@ -701,12 +704,24 @@ super void forceRun() {
 
 ### shuffled
 
-Allows multiple return values.
+Allows multiple return values with tuple unpacking.
 
 ```cssl
 shuffled string getNames() {
     return "Alice", "Bob", "Charlie";
 }
+
+// Tuple unpacking (v3.7.6+)
+a, b, c = getNames();
+printl(a);  // "Alice"
+printl(b);  // "Bob"
+printl(c);  // "Charlie"
+
+// Works with any types
+shuffled getValues() {
+    return "text", 42, true;
+}
+name, num, flag = getValues();
 ```
 
 ---
@@ -1143,6 +1158,10 @@ print(stats.total)  # 50 - Persisted!
 
 CodeInfusion enables modifying functions at runtime.
 
+> **Important**: Injection operators must be written **without spaces**:
+> - ✓ `func() <<==` / `func() +<<==` / `func() -<<==` (correct)
+> - ✗ `func() < <==` / `func() + <<==` / `func() - <<==` (wrong)
+
 ### <<== (Replace)
 
 Replaces function content.

includecpp/core/cssl/cssl_parser.py

@@ -1629,23 +1629,42 @@ class CSSLParser:
         return ASTNode('c_for_update', value={'var': var_name, 'op': 'none'})
 
     def _parse_python_style_for(self) -> ASTNode:
-        """Parse Python-style for loop: for (i in range(...)) { }
+        """Parse Python-style for loop: for (i in range(...)) { } or for (item in collection) { }
 
         Supports:
             for (i in range(n)) { }           - 0 to n-1
             for (i in range(start, end)) { }  - start to end-1
             for (i in range(start, end, step)) { }
+            for (item in collection) { }      - iterate over list/vector
+            for (item in @global_collection) { } - iterate over global
         """
         var_name = self._advance().value
         self._expect(TokenType.KEYWORD)  # 'in'
 
-        # 'range' can be keyword or identifier
+        # Check if this is range() or collection iteration
+        is_range = False
         if self._check(TokenType.KEYWORD) and self._peek().value == 'range':
             self._advance()  # consume 'range' keyword
+            is_range = True
         elif self._check(TokenType.IDENTIFIER) and self._peek().value == 'range':
             self._advance()  # consume 'range' identifier
-        else:
-            self.error(f"Expected 'range', got {self._peek().value}")
+            is_range = True
+
+        # If not range, parse as collection iteration
+        if not is_range:
+            iterable = self._parse_expression()
+            self._expect(TokenType.PAREN_END)
+
+            node = ASTNode('foreach', value={'var': var_name, 'iterable': iterable}, children=[])
+            self._expect(TokenType.BLOCK_START)
+
+            while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                stmt = self._parse_statement()
+                if stmt:
+                    node.children.append(stmt)
+
+            self._expect(TokenType.BLOCK_END)
+            return node
 
         self._expect(TokenType.PAREN_START)
         first_arg = self._parse_expression()
@@ -1757,11 +1776,31 @@ class CSSLParser:
         return node
 
     def _parse_return(self) -> ASTNode:
-        value = None
+        """Parse return statement, supporting multiple values for shuffled functions.
+
+        Syntax:
+            return;                    // Return None
+            return value;              // Return single value
+            return a, b, c;            // Return multiple values (for shuffled)
+        """
+        values = []
         if not self._check(TokenType.SEMICOLON) and not self._check(TokenType.BLOCK_END):
-            value = self._parse_expression()
+            values.append(self._parse_expression())
+
+            # Check for comma-separated return values (shuffled return)
+            while self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                values.append(self._parse_expression())
+
         self._match(TokenType.SEMICOLON)
-        return ASTNode('return', value=value)
+
+        if len(values) == 0:
+            return ASTNode('return', value=None)
+        elif len(values) == 1:
+            return ASTNode('return', value=values[0])
+        else:
+            # Multiple return values - create tuple return
+            return ASTNode('return', value={'multiple': True, 'values': values})
 
     def _parse_super_function(self) -> ASTNode:
         """Parse super-function for .cssl-pl payload files.
@@ -1873,6 +1912,25 @@ class CSSLParser:
     def _parse_expression_statement(self) -> Optional[ASTNode]:
         expr = self._parse_expression()
 
+        # === TUPLE UNPACKING: a, b, c = shuffled_func() ===
+        # Check if we have comma-separated identifiers before =
+        if expr.type == 'identifier' and self._check(TokenType.COMMA):
+            targets = [expr]
+            while self._match(TokenType.COMMA):
+                next_expr = self._parse_expression()
+                if next_expr.type == 'identifier':
+                    targets.append(next_expr)
+                else:
+                    # Not a simple identifier list, this is something else
+                    # Restore and fall through to normal parsing
+                    break
+
+            # Check if followed by =
+            if self._match(TokenType.EQUALS):
+                value = self._parse_expression()
+                self._match(TokenType.SEMICOLON)
+                return ASTNode('tuple_assignment', value={'targets': targets, 'value': value})
+
         # === BASIC INJECTION: <== (replace target with source) ===
         if self._match(TokenType.INJECT_LEFT):
             # Check if this is a createcmd injection with a code block

includecpp/core/cssl/cssl_runtime.py

@@ -963,10 +963,20 @@ class CSSLRuntime:
 
         # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
-            # Extract param name from dict format: {'name': 'a', 'type': 'int'}
-            param_name = param['name'] if isinstance(param, dict) else param
-
-            if param_name in kwargs:
+            # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
+            if isinstance(param, dict):
+                param_name = param['name']
+                param_type = param.get('type', '')
+            else:
+                param_name = param
+                param_type = ''
+
+            # Check if this is an 'open' parameter - receives all args as a list
+            if param_type == 'open' or param_name == 'Params':
+                # 'open Params' receives all arguments as a list
+                new_scope.set(param_name, list(args))
+                new_scope.set('Params', list(args))  # Also set 'Params' for OpenFind
+            elif param_name in kwargs:
                 # Named argument takes priority
                 new_scope.set(param_name, kwargs[param_name])
             elif i < len(args):
@@ -1176,8 +1186,20 @@ class CSSLRuntime:
         return None
 
     def _exec_return(self, node: ASTNode) -> Any:
-        """Execute return statement"""
-        value = self._evaluate(node.value) if node.value else None
+        """Execute return statement.
+
+        Supports multiple return values for shuffled functions:
+            return a, b, c;  // Returns tuple (a, b, c)
+        """
+        if node.value is None:
+            raise CSSLReturn(None)
+
+        # Check if this is a multiple return value
+        if isinstance(node.value, dict) and node.value.get('multiple'):
+            values = [self._evaluate(v) for v in node.value.get('values', [])]
+            raise CSSLReturn(tuple(values))
+
+        value = self._evaluate(node.value)
         raise CSSLReturn(value)
 
     def _exec_break(self, node: ASTNode) -> Any:
@@ -1804,6 +1826,36 @@ class CSSLRuntime:
 
         return value
 
+    def _exec_tuple_assignment(self, node: ASTNode) -> Any:
+        """Execute tuple unpacking assignment: a, b, c = shuffled_func()
+
+        Used with shuffled functions that return multiple values.
+        """
+        targets = node.value.get('targets', [])
+        value = self._evaluate(node.value.get('value'))
+
+        # Convert value to list if it's a tuple or iterable
+        if isinstance(value, (list, tuple)):
+            values = list(value)
+        elif hasattr(value, '__iter__') and not isinstance(value, (str, dict)):
+            values = list(value)
+        else:
+            # Single value - assign to first target only
+            values = [value]
+
+        # Assign values to targets
+        for i, target in enumerate(targets):
+            if i < len(values):
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, values[i])
+            else:
+                # More targets than values - set to None
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, None)
+
+        # Assignment statements don't produce a visible result
+        return None
+
     def _exec_expression(self, node: ASTNode) -> Any:
         """Execute expression statement"""
         return self._evaluate(node.value)

includecpp/vscode/cssl/language-configuration.json

@@ -6,14 +6,12 @@
     "brackets": [
         ["{", "}"],
         ["[", "]"],
-        ["(", ")"],
-        ["<", ">"]
+        ["(", ")"]
     ],
     "autoClosingPairs": [
         { "open": "{", "close": "}" },
         { "open": "[", "close": "]" },
         { "open": "(", "close": ")" },
-        { "open": "<", "close": ">" },
         { "open": "\"", "close": "\"", "notIn": ["string"] },
         { "open": "'", "close": "'", "notIn": ["string", "comment"] }
     ],
@@ -21,7 +19,6 @@
         ["{", "}"],
         ["[", "]"],
         ["(", ")"],
-        ["<", ">"],
         ["\"", "\""],
         ["'", "'"]
     ],

includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -3,15 +3,18 @@
     "name": "CSSL",
     "scopeName": "source.cssl",
     "patterns": [
+        { "include": "#super-functions" },
         { "include": "#comments" },
         { "include": "#strings" },
         { "include": "#numbers" },
         { "include": "#class-definition" },
+        { "include": "#sql-types" },
         { "include": "#keywords" },
         { "include": "#types" },
         { "include": "#function-modifiers" },
         { "include": "#injection-operators" },
         { "include": "#namespace-functions" },
+        { "include": "#iterator-methods" },
         { "include": "#filter-helpers" },
         { "include": "#this-access" },
         { "include": "#captured-references" },
@@ -19,12 +22,26 @@
         { "include": "#shared-references" },
         { "include": "#instance-references" },
         { "include": "#module-references" },
+        { "include": "#reference-operator" },
+        { "include": "#method-calls" },
         { "include": "#function-calls" },
         { "include": "#builtins" },
         { "include": "#operators" },
         { "include": "#constants" }
     ],
     "repository": {
+        "super-functions": {
+            "patterns": [
+                {
+                    "name": "markup.bold.super.builtin.cssl",
+                    "match": "#\\$(run|exec|printl|init)\\b"
+                },
+                {
+                    "name": "markup.bold.super.call.cssl",
+                    "match": "#\\$[a-zA-Z_][a-zA-Z0-9_]*"
+                }
+            ]
+        },
         "comments": {
             "patterns": [
                 {
@@ -49,6 +66,10 @@
                             "name": "constant.character.escape.cssl",
                             "match": "\\\\."
                         },
+                        {
+                            "name": "variable.other.interpolated.fstring.cssl",
+                            "match": "\\{[a-zA-Z_][a-zA-Z0-9_]*\\}"
+                        },
                         {
                             "name": "variable.other.interpolated.cssl",
                             "match": "<[a-zA-Z_][a-zA-Z0-9_]*>"
@@ -118,6 +139,18 @@
                 }
             ]
         },
+        "sql-types": {
+            "patterns": [
+                {
+                    "name": "support.type.sql.table.cssl",
+                    "match": "\\bsql::table::(space|Section|limited|protected)\\b"
+                },
+                {
+                    "name": "support.type.sql.cssl",
+                    "match": "\\bsql::(table|data|data__list|sync|db)\\b"
+                }
+            ]
+        },
         "keywords": {
             "patterns": [
                 {
@@ -130,7 +163,7 @@
                 },
                 {
                     "name": "keyword.other.cssl",
-                    "match": "\\b(service-init|service-run|service-include|struct|structure|define|main|package|package-includes|exec|as|global|include|get|payload)\\b"
+                    "match": "\\b(service-init|service-run|service-include|struct|structure|define|main|package|package-includes|exec|as|global|include|get|payload|convert)\\b"
                 },
                 {
                     "name": "keyword.operator.logical.cssl",
@@ -146,18 +179,26 @@
             "patterns": [
                 {
                     "name": "storage.type.primitive.cssl",
-                    "match": "\\b(int|string|float|bool|void|json|dynamic)\\b"
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\b"
                 },
                 {
                     "name": "storage.type.container.cssl",
-                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance)\\b"
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\b"
                 },
                 {
                     "name": "storage.type.generic.cssl",
-                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance)\\s*<",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\s*<",
                     "captures": {
                         "1": { "name": "storage.type.container.cssl" }
                     }
+                },
+                {
+                    "name": "storage.type.map-literal.cssl",
+                    "match": "\\bmap\\s*<[^>]+>\\s*\\{"
+                },
+                {
+                    "name": "storage.type.combo-open.cssl",
+                    "match": "\\bcombo\\s*<\\s*open\\s*&"
                 }
             ]
         },
@@ -165,19 +206,27 @@
             "patterns": [
                 {
                     "name": "storage.modifier.cssl",
-                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased)\\b"
+                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited)\\b"
                 }
             ]
         },
         "injection-operators": {
             "patterns": [
                 {
-                    "name": "keyword.operator.injection.infuse.cssl",
-                    "match": "(\\+<<==|<<==|-<<==|==>>\\+|==>>|-==>>)"
+                    "name": "entity.name.tag.infuse.cssl",
+                    "match": "(\\+<<==|<<==|-<<==)"
+                },
+                {
+                    "name": "entity.name.tag.infuse.out.cssl",
+                    "match": "(==>>\\+|==>>|-==>>)"
                 },
                 {
                     "name": "keyword.operator.injection.brute.cssl",
-                    "match": "(\\+<==|<==|-<==|==>\\+|==>|-==>)"
+                    "match": "(\\+<==|<==|-<==)"
+                },
+                {
+                    "name": "keyword.operator.injection.brute.out.cssl",
+                    "match": "(==>\\+|==>|-==>)"
                 },
                 {
                     "name": "keyword.operator.flow.cssl",
@@ -189,7 +238,7 @@
             "patterns": [
                 {
                     "name": "support.function.namespace.json.cssl",
-                    "match": "\\bjson::(read|write|parse|stringify|pretty|get|set|has|keys|values|merge)\\b"
+                    "match": "\\bjson::(read|write|parse|stringify|pretty|get|set|has|keys|values|merge|key|value)\\b"
                 },
                 {
                     "name": "support.function.namespace.instance.cssl",
@@ -198,6 +247,26 @@
                 {
                     "name": "support.function.namespace.string.cssl",
                     "match": "\\bstring::(where|contains|not|startsWith|endsWith|length|lenght|cut|cutAfter|value)\\b"
+                },
+                {
+                    "name": "support.function.namespace.sql.cssl",
+                    "match": "\\bsql::(connect|load|save|update|sync|Structured)\\b"
+                },
+                {
+                    "name": "support.function.namespace.combo.cssl",
+                    "match": "\\bcombo::(filterdb|blocked|like)\\b"
+                }
+            ]
+        },
+        "iterator-methods": {
+            "patterns": [
+                {
+                    "name": "support.function.iterator.cssl",
+                    "match": "::iterator::(set|move|insert|pop|task|dtask|read|write)\\b"
+                },
+                {
+                    "name": "support.function.like.cssl",
+                    "match": "::like\\s*="
                 }
             ]
         },
@@ -205,7 +274,7 @@
             "patterns": [
                 {
                     "name": "support.function.filter.cssl",
-                    "match": "\\b(string|integer|json|array|vector|combo|dynamic|sql)::(where|contains|not|startsWith|endsWith|length|lenght|key|value|index|filterdb|blocked|data)\\b"
+                    "match": "\\[(string|integer|json|array|vector|combo|dynamic|sql)::(where|contains|not|startsWith|endsWith|length|lenght|key|value|index|filterdb|blocked|data)\\s*=?"
                 }
             ]
         },
@@ -269,6 +338,22 @@
                 }
             ]
         },
+        "reference-operator": {
+            "patterns": [
+                {
+                    "name": "keyword.operator.reference.cssl",
+                    "match": "&(?=[a-zA-Z_@])"
+                }
+            ]
+        },
+        "method-calls": {
+            "patterns": [
+                {
+                    "name": "support.function.method.cssl",
+                    "match": "\\.(push_back|append|insert|fill|at|is|read|write|content|save|where|load|update|oqt|connect|Structured|create|Queue|sync|pop|end|get|set|has|keys|values|convert)\\b"
+                }
+            ]
+        },
         "function-calls": {
             "patterns": [
                 {
@@ -293,7 +378,7 @@
                 },
                 {
                     "name": "support.function.builtin.special.cssl",
-                    "match": "\\b(OpenFind|share|shared)\\b"
+                    "match": "\\b(OpenFind|share|shared|include)\\b"
                 },
                 {
                     "name": "support.variable.builtin.parameter.cssl",

{includecpp-3.7.4.dist-info → includecpp-3.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.4
+Version: 3.7.6
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.7.4.dist-info → includecpp-3.7.6.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=U1Oe_B1GhcdlcFarJUW7D823p6nVlB9suWIvQhhXTmM,1672
+includecpp/__init__.py,sha256=B6a0CroJHkuHfRN0gAFLyQZaafrI8Wb8pysFveVSTas,1672
 includecpp/__init__.pyi,sha256=c4gZW7_XQXcp6FBcTi5W7zXTmCtbgQhlC4cyeVqtRRM,7253
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=-fuSeL2Rrag5tBIoE5Mxz7Y4dsGA6sogwINtKWSTXFE,344523
+includecpp/cli/commands.py,sha256=9PAYEMbixk2EvorcwZunSRJbyAdPSzt67NsVM5qdjLQ,346027
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
@@ -19,14 +19,14 @@ includecpp/core/exceptions.py,sha256=szeF4qdzi_q8hBBZi7mJxkliyQ0crplkLYe0ymlBGtk
 includecpp/core/path_discovery.py,sha256=jI0oSq6Hsd4LKXmU4dOiGSrXcEO_KWMXfQ5_ylBmXvU,2561
 includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ,141134
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
-includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=ect_C81V4IiMYUGNj61O2dg0SMZgO9_Sv26lkLM2qNs,40035
+includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=47sUPO-FMq_8_CrJBZFoFBgSO3gSi5zoB1Xp7oeifho,40773
 includecpp/core/cssl/__init__.py,sha256=TYRlyheTw5OYkkmUxJYpAjyyQShu6NF4igYZYE76eR0,1811
 includecpp/core/cssl/cssl_builtins.py,sha256=MJtWF7PeWkasxxkpN2zaCjeIJoQw5BPy-jQNYberMQo,85010
 includecpp/core/cssl/cssl_builtins.pyi,sha256=Zc__PCO9FDaTPPG92zgK6_QoeMohbs0xlv6YGPubEdQ,31010
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
-includecpp/core/cssl/cssl_parser.py,sha256=qml36aY0j0_trVWNUH3VxexeKld429s3ucAM3FyfbIA,110619
-includecpp/core/cssl/cssl_runtime.py,sha256=FLsfIsLER9NTjUZw_97w3xWltVNOGsYWzCWkDMLnUQY,129599
+includecpp/core/cssl/cssl_parser.py,sha256=pOWe6kle4EvXLai3DNHfLcYGeb568EQ8upxscVVR5m0,113161
+includecpp/core/cssl/cssl_runtime.py,sha256=3b14wEWvLpFDVA0r0pyNqy02l7s9FTdXQd61BdpPlZg,131780
 includecpp/core/cssl/cssl_syntax.py,sha256=vgI-dgj6gs9cOHwNRff6JbwZZYW_fYutnwCkznlgZiE,17006
 includecpp/core/cssl/cssl_types.py,sha256=XftmkvjxL-mKMz6HiTtnruG6P7haM21gFm7P9Caovug,48213
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
@@ -37,13 +37,13 @@ includecpp/generator/type_resolver.h,sha256=ZsaxQqcCcKJJApYn7KOp2dLlQ1VFVG_oZDja
 includecpp/templates/cpp.proj.template,sha256=Iy-L8I4Cl3tIgBMx1Qp5h6gURvkqOAqyodVHuDJ0Luw,359
 includecpp/vscode/__init__.py,sha256=yLKw-_7MTX1Rx3jLk5JjharJQfFXbwtZVE7YqHpM7yg,39
 includecpp/vscode/cssl/__init__.py,sha256=rQJAx5X05v-mAwqX1Qb-rbZO219iR73MziFNRUCNUIo,31
-includecpp/vscode/cssl/language-configuration.json,sha256=vBZSVBpV0UFlTO4d0aQrhTpR4lHje0Tb2n889k9W_Uc,986
+includecpp/vscode/cssl/language-configuration.json,sha256=61Q00cKI9may5L8YpxMmvfo6PAc-abdJqApfR85DWuw,904
 includecpp/vscode/cssl/package.json,sha256=MWWIRLUnGvadWzEyfWdykUZHTsrG18sqpn5US5sXqac,1435
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=l4SCEPR3CsPxA8HIVLKYY__I979TfKzYWtH1KYIsboo,33062
-includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=FODjb4v7K9qScxmiUP4HLgTNk6nDHF_HMqUA2HfyzLM,12747
-includecpp-3.7.4.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.7.4.dist-info/METADATA,sha256=2FvXv35JJsnkcLsCBr0gTG6VSryzuqZUEWyVk4oNkrc,32122
-includecpp-3.7.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.7.4.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.7.4.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.7.4.dist-info/RECORD,,
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=t_AjAgZl16ugNhuU-OlIb4Q6SCOLsnQ3DPK2R0xotGk,16091
+includecpp-3.7.6.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.7.6.dist-info/METADATA,sha256=4GXuFRMpXcGjvxCEL0TvzbKDdW6bNUQHDJYh9bLQcao,32122
+includecpp-3.7.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.7.6.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.7.6.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.7.6.dist-info/RECORD,,