IncludeCPP 3.7.20__py3-none-any.whl → 3.7.22__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.20"
+__version__ = "3.7.22"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/cli/commands.py

@@ -7720,7 +7720,13 @@ def cssl_doc(search, list_sections):
                     click.echo("Or use: includecpp cssl doc --list")
         else:
             # Full documentation mode
-            click.echo_via_pager(content)
+            # Replace Unicode characters that may not be supported on all terminals
+            safe_content = content.replace('✓', '[OK]').replace('✗', '[X]').replace('→', '->').replace('←', '<-').replace('•', '*').replace('─', '-').replace('│', '|').replace('└', '+').replace('├', '+').replace('▸', '>').replace('▾', 'v')
+            try:
+                click.echo_via_pager(safe_content)
+            except UnicodeEncodeError:
+                # Fallback: encode with errors='replace'
+                click.echo(safe_content.encode('ascii', errors='replace').decode('ascii'))
     else:
         click.secho("Documentation file not found.", fg='yellow')
         click.echo("Looking for: CSSL_DOCUMENTATION.md")

includecpp/core/cssl/cssl_builtins.py

@@ -307,6 +307,10 @@ class CSSLBuiltins:
         self._functions['dataspace'] = self.builtin_dataspace
         self._functions['openquote'] = self.builtin_openquote
         self._functions['OpenFind'] = self.builtin_openfind
+        self._functions['vector'] = self.builtin_vector
+        self._functions['array'] = self.builtin_array
+        self._functions['stack'] = self.builtin_stack
+        self._functions['map'] = self.builtin_map
 
         # Print aliases for CSSL
         self._functions['printl'] = self.builtin_println  # CSSL uses printl for println
@@ -433,13 +437,50 @@ class CSSLBuiltins:
     # ============= Type Checking =============
 
     def builtin_typeof(self, value: Any) -> str:
-        """Get type name"""
+        """Get type name - returns CSSL-specific type names for CSSL types"""
         if value is None:
             return 'null'
+
+        # Check CSSL-specific types first
+        from .cssl_types import (Vector, Array, Stack, DataStruct,
+                                  List as CSSLList, Dictionary, Map,
+                                  Shuffled, Iterator, Combo, DataSpace,
+                                  OpenQuote, Parameter, CSSLInstance)
+
+        if isinstance(value, Vector):
+            return 'vector'
+        elif isinstance(value, Array):
+            return 'array'
+        elif isinstance(value, Stack):
+            return 'stack'
+        elif isinstance(value, DataStruct):
+            return 'datastruct'
+        elif isinstance(value, CSSLList):
+            return 'list'
+        elif isinstance(value, Dictionary):
+            return 'dictionary'
+        elif isinstance(value, Map):
+            return 'map'
+        elif isinstance(value, Shuffled):
+            return 'shuffled'
+        elif isinstance(value, Iterator):
+            return 'iterator'
+        elif isinstance(value, Combo):
+            return 'combo'
+        elif isinstance(value, DataSpace):
+            return 'dataspace'
+        elif isinstance(value, OpenQuote):
+            return 'openquote'
+        elif isinstance(value, Parameter):
+            return 'parameter'
+        elif isinstance(value, CSSLInstance):
+            return value._class.name
+
+        # Python types as fallback
         type_map = {
             int: 'int',
             float: 'float',
-            str: 'str',
+            str: 'string',
             bool: 'bool',
             list: 'list',
             dict: 'dict',
@@ -2322,6 +2363,38 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
+    def builtin_vector(self, element_type: str = 'dynamic') -> Any:
+        """Create a vector container.
+
+        Usage: vector<int> myVector; or vector('int')
+        """
+        from .cssl_types import Vector
+        return Vector(element_type)
+
+    def builtin_array(self, element_type: str = 'dynamic') -> Any:
+        """Create an array container.
+
+        Usage: array<string> myArray; or array('string')
+        """
+        from .cssl_types import Array
+        return Array(element_type)
+
+    def builtin_stack(self, element_type: str = 'dynamic') -> Any:
+        """Create a stack container.
+
+        Usage: stack<int> myStack; or stack('int')
+        """
+        from .cssl_types import Stack
+        return Stack(element_type)
+
+    def builtin_map(self, key_type: str = 'dynamic', value_type: str = 'dynamic') -> Any:
+        """Create a map container.
+
+        Usage: map<string, int> myMap; or map('string', 'int')
+        """
+        from .cssl_types import Map
+        return Map(key_type, value_type)
+
     def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.
 

includecpp/core/cssl/cssl_parser.py

@@ -252,8 +252,15 @@ class CSSLLexer:
                 # $<name> shared object reference
                 self._read_shared_ref()
             elif char == '%':
-                # %<name> captured reference (for infusion)
-                self._read_captured_ref()
+                # Check if this is %<name> captured reference or % modulo operator
+                next_char = self._peek(1)
+                if next_char and (next_char.isalpha() or next_char == '_'):
+                    # %<name> captured reference (for infusion)
+                    self._read_captured_ref()
+                else:
+                    # % modulo operator
+                    self._add_token(TokenType.MODULO, '%')
+                    self._advance()
             elif char == '&':
                 # & for references
                 if self._peek(1) == '&':
@@ -321,9 +328,6 @@ class CSSLLexer:
                 else:
                     # Already handled by // comment check above, but just in case
                     self._skip_comment()
-            elif char == '%':
-                self._add_token(TokenType.MODULO, '%')
-                self._advance()
             elif char == '<':
                 self._read_less_than()
             elif char == '>':
@@ -848,7 +852,7 @@ class CSSLParser:
             if self._match_keyword('open'):
                 param_info['open'] = True
 
-            # Handle type annotations
+            # Handle type annotations (builtin types like int, string, etc.)
             if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 param_info['type'] = self._advance().value
 
@@ -872,6 +876,39 @@ class CSSLParser:
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
+            # Handle custom class types (identifier followed by another identifier = type + name)
+            elif self._check(TokenType.IDENTIFIER):
+                # Look ahead: if next token is also an identifier, current is the type
+                saved_pos = self.pos
+                potential_type = self._advance().value
+
+                # Check for generic type parameter <T> on custom type
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()
+                    generic_parts = []
+                    depth = 1
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                            generic_parts.append('<')
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                            if depth > 0:
+                                generic_parts.append('>')
+                        elif self._check(TokenType.COMMA):
+                            generic_parts.append(',')
+                        else:
+                            generic_parts.append(self._current().value)
+                        self._advance()
+                    param_info['generic'] = ''.join(generic_parts)
+
+                # If followed by identifier, this is "Type name" pattern
+                if self._check(TokenType.IDENTIFIER):
+                    param_info['type'] = potential_type
+                else:
+                    # Not a type, restore position - this is just a param name
+                    self.pos = saved_pos
+
             # Handle reference operator &
             if self._match(TokenType.AMPERSAND):
                 param_info['ref'] = True
@@ -2509,6 +2546,20 @@ class CSSLParser:
 
                 self._expect(TokenType.BLOCK_END)  # consume }
 
+            # Check for array-style initialization: vector<int>[1, 2, 3], array<string>["a", "b"]
+            elif self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                init_values = []
+
+                while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                    init_values.append(self._parse_expression())
+
+                    # Optional comma
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+
+                self._expect(TokenType.BRACKET_END)  # consume ]
+
             return ASTNode('type_instantiation', value={
                 'type': name,
                 'element_type': element_type,

includecpp/core/cssl/cssl_runtime.py

@@ -830,8 +830,18 @@ class CSSLRuntime:
                 if hasattr(instance, 'append'):
                     instance.append(init_value)
 
+        # Check for global modifier
+        modifiers = decl.get('modifiers', [])
+        is_global = 'global' in modifiers
+
         # Store in scope
         self.scope.set(var_name, instance)
+
+        # If global, also store in promoted_globals and global_scope
+        if is_global:
+            self._promoted_globals[var_name] = instance
+            self.global_scope.set(var_name, instance)
+
         return instance
 
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
@@ -978,6 +988,14 @@ class CSSLRuntime:
             result = self._evaluate(inner.value)
             return result
 
+        # Handle typed declaration: global datastruct<int> data;
+        elif inner.type == 'typed_declaration':
+            # Add global modifier to the declaration
+            if isinstance(inner.value, dict):
+                inner.value['modifiers'] = inner.value.get('modifiers', []) + ['global']
+            result = self._exec_typed_declaration(inner)
+            return result
+
         # Fallback: execute normally
         return self._execute_node(inner)
 
@@ -1536,13 +1554,112 @@ class CSSLRuntime:
 
                 # === DYNAMIC HELPERS ===
                 elif filter_type == 'dynamic':
-                    # dynamic::VarName=VALUE - Match if variable equals value
-                    var_name = helper
-                    var_value = self.scope.get(var_name)
-                    if var_value == filter_val:
-                        pass  # Keep result
+                    if helper == 'content':
+                        # dynamic::content=VALUE - General content filter for any type
+                        # Filters elements where content equals VALUE
+                        if isinstance(result, (list, tuple)):
+                            # Filter list/tuple elements by content value
+                            result = [item for item in result if item == filter_val]
+                        elif isinstance(result, dict):
+                            # Filter dict by values matching filter_val
+                            result = {k: v for k, v in result.items() if v == filter_val}
+                        elif result == filter_val:
+                            pass  # Keep result if it matches
+                        else:
+                            result = None
+                    elif helper == 'not':
+                        # dynamic::not=VALUE - Exclude elements equal to VALUE
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item != filter_val]
+                        elif isinstance(result, dict):
+                            result = {k: v for k, v in result.items() if v != filter_val}
+                        elif result != filter_val:
+                            pass  # Keep result if it doesn't match
+                        else:
+                            result = None
+                    elif helper == 'gt':
+                        # dynamic::gt=VALUE - Greater than
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item > filter_val]
+                        elif result > filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'lt':
+                        # dynamic::lt=VALUE - Less than
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item < filter_val]
+                        elif result < filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'gte':
+                        # dynamic::gte=VALUE - Greater than or equal
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item >= filter_val]
+                        elif result >= filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'lte':
+                        # dynamic::lte=VALUE - Less than or equal
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item <= filter_val]
+                        elif result <= filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'mod':
+                        # dynamic::mod=VALUE - Modulo filter (item % VALUE == 0)
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, (int, float)) and item % filter_val == 0]
+                        elif isinstance(result, (int, float)) and result % filter_val == 0:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'range':
+                        # dynamic::range="min:max" - Filter values in range
+                        if isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':')
+                            min_val = int(parts[0]) if parts[0] else None
+                            max_val = int(parts[1]) if parts[1] else None
+                            if isinstance(result, (list, tuple)):
+                                def in_range(x):
+                                    if min_val is not None and x < min_val:
+                                        return False
+                                    if max_val is not None and x > max_val:
+                                        return False
+                                    return True
+                                result = [item for item in result if in_range(item)]
+                            elif isinstance(result, (int, float)):
+                                if min_val is not None and result < min_val:
+                                    result = None
+                                elif max_val is not None and result > max_val:
+                                    result = None
+                    elif helper == 'even':
+                        # dynamic::even - Filter even numbers
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, int) and item % 2 == 0]
+                        elif isinstance(result, int) and result % 2 == 0:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'odd':
+                        # dynamic::odd - Filter odd numbers
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, int) and item % 2 != 0]
+                        elif isinstance(result, int) and result % 2 != 0:
+                            pass
+                        else:
+                            result = None
                     else:
-                        result = None
+                        # dynamic::VarName=VALUE - Match if variable equals value
+                        var_name = helper
+                        var_value = self.scope.get(var_name)
+                        if var_value == filter_val:
+                            pass  # Keep result
+                        else:
+                            result = None
 
                 # === SQL HELPERS ===
                 elif filter_type == 'sql':
@@ -1756,9 +1873,14 @@ class CSSLRuntime:
         elif mode == 'move':
             # Move & remove from source
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Clear the source - handle all node types
+            if isinstance(source_node, ASTNode):
+                if source_node.type == 'identifier':
+                    self.scope.set(source_node.value, None)
+                elif source_node.type == 'module_ref':
+                    self._set_module_value(source_node.value, None)
+                elif source_node.type == 'member_access':
+                    self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -1830,9 +1952,36 @@ class CSSLRuntime:
                 final_value = [current_value, source]
         elif mode == 'move':
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Remove filtered elements from source (not clear entirely)
+            if isinstance(source_node, ASTNode):
+                if filter_info:
+                    # Get original source value
+                    original_source = self._evaluate(source_node)
+                    if isinstance(original_source, list) and isinstance(final_value, list):
+                        # Remove filtered items from original list
+                        remaining = [item for item in original_source if item not in final_value]
+                        if source_node.type == 'identifier':
+                            self.scope.set(source_node.value, remaining)
+                        elif source_node.type == 'module_ref':
+                            self._set_module_value(source_node.value, remaining)
+                        elif source_node.type == 'member_access':
+                            self._set_member(source_node, remaining)
+                    else:
+                        # Single value filter - set source to None
+                        if source_node.type == 'identifier':
+                            self.scope.set(source_node.value, None)
+                        elif source_node.type == 'module_ref':
+                            self._set_module_value(source_node.value, None)
+                        elif source_node.type == 'member_access':
+                            self._set_member(source_node, None)
+                else:
+                    # No filter - clear entire source
+                    if source_node.type == 'identifier':
+                        self.scope.set(source_node.value, None)
+                    elif source_node.type == 'module_ref':
+                        self._set_module_value(source_node.value, None)
+                    elif source_node.type == 'member_access':
+                        self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -2132,12 +2281,13 @@ class CSSLRuntime:
             return value
 
         if node.type == 'module_ref':
-            # Check modules first, then promoted globals, then scope
-            value = self.get_module(node.value)
-            if value is None:
-                value = self._promoted_globals.get(node.value)
+            # User-defined globals have priority over SDK modules
+            # Check promoted globals first, then global scope, then SDK modules
+            value = self._promoted_globals.get(node.value)
             if value is None:
                 value = self.global_scope.get(node.value)
+            if value is None:
+                value = self.get_module(node.value)  # SDK modules as fallback
             return value
 
         if node.type == 'self_ref':
@@ -2221,12 +2371,28 @@ class CSSLRuntime:
             value_type = node.value.get('value_type')  # For map<K, V>
             init_values = node.value.get('init_values')  # For inline init: map<K,V>{...}
 
+            # Helper to populate container with init values
+            def _populate_container(container, init_vals):
+                if init_vals and isinstance(init_vals, list):
+                    for val_node in init_vals:
+                        val = self._evaluate(val_node) if isinstance(val_node, ASTNode) else val_node
+                        if hasattr(container, 'push'):
+                            container.push(val)
+                        elif hasattr(container, 'add'):
+                            container.add(val)
+                        elif hasattr(container, 'append'):
+                            container.append(val)
+                return container
+
             if type_name == 'stack':
-                return Stack(element_type)
+                s = Stack(element_type)
+                return _populate_container(s, init_values)
             elif type_name == 'vector':
-                return Vector(element_type)
+                v = Vector(element_type)
+                return _populate_container(v, init_values)
             elif type_name == 'datastruct':
-                return DataStruct(element_type)
+                d = DataStruct(element_type)
+                return _populate_container(d, init_values)
             elif type_name == 'shuffled':
                 return Shuffled(element_type)
             elif type_name == 'iterator':
@@ -2238,9 +2404,11 @@ class CSSLRuntime:
             elif type_name == 'openquote':
                 return OpenQuote()
             elif type_name == 'array':
-                return Array(element_type)
+                a = Array(element_type)
+                return _populate_container(a, init_values)
             elif type_name == 'list':
-                return List(element_type)
+                l = List(element_type)
+                return _populate_container(l, init_values)
             elif type_name in ('dictionary', 'dict'):
                 return Dictionary(element_type)
             elif type_name == 'map':
@@ -3027,12 +3195,20 @@ class CSSLRuntime:
                 pass
 
     def _set_module_value(self, path: str, value: Any):
-        """Set a value on a module path"""
+        """Set a value on a module path or promoted global"""
         parts = path.split('.')
         if len(parts) < 2:
+            # Single name (no dots) - set in promoted_globals and global_scope
+            self._promoted_globals[path] = value
+            self.global_scope.set(path, value)
             return
 
         obj = self._modules.get(parts[0])
+        # Also check promoted_globals for the base object
+        if obj is None:
+            obj = self._promoted_globals.get(parts[0])
+        if obj is None:
+            obj = self.global_scope.get(parts[0])
         if obj is None:
             return
 

includecpp/core/cssl/cssl_types.py

@@ -64,6 +64,33 @@ class DataStruct(list):
             return target_type(self[0])
         return None
 
+    def length(self) -> int:
+        """Return datastruct length"""
+        return len(self)
+
+    def size(self) -> int:
+        """Return datastruct size (alias for length)"""
+        return len(self)
+
+    def push(self, item: Any) -> 'DataStruct':
+        """Push item to datastruct (alias for add)"""
+        self.append(item)
+        return self
+
+    def isEmpty(self) -> bool:
+        """Check if datastruct is empty"""
+        return len(self) == 0
+
+    def contains(self, item: Any) -> bool:
+        """Check if datastruct contains item"""
+        return item in self
+
+    def at(self, index: int) -> Any:
+        """Get item at index (safe access)"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
     def begin(self) -> int:
         """Return iterator to beginning (C++ style)"""
         return 0
@@ -99,6 +126,16 @@ class Stack(list):
         self.append(item)
         return self
 
+    def pop(self) -> Any:
+        """Pop and return top element from stack"""
+        if len(self) == 0:
+            return None
+        return super().pop()
+
+    def pop_back(self) -> Any:
+        """Pop and return top element (alias for pop)"""
+        return self.pop()
+
     def peek(self) -> Any:
         """View top item without removing"""
         return self[-1] if self else None
@@ -701,6 +738,39 @@ class List(list):
             self.extend([value] * count)
         return self
 
+    def map(self, func: Callable[[Any], Any]) -> 'List':
+        """Apply function to all elements"""
+        result = List(self._element_type)
+        result.extend(func(item) for item in self)
+        return result
+
+    def filter(self, predicate: Callable[[Any], bool]) -> 'List':
+        """Filter elements by predicate"""
+        result = List(self._element_type)
+        result.extend(item for item in self if predicate(item))
+        return result
+
+    def forEach(self, func: Callable[[Any], None]) -> 'List':
+        """Execute function for each element"""
+        for item in self:
+            func(item)
+        return self
+
+    def reduce(self, func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+        """Reduce list to single value"""
+        from functools import reduce as py_reduce
+        if initial is None:
+            return py_reduce(func, self)
+        return py_reduce(func, self, initial)
+
+    def every(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if all elements match predicate"""
+        return all(predicate(item) for item in self)
+
+    def some(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if any element matches predicate"""
+        return any(predicate(item) for item in self)
+
     def begin(self) -> int:
         """Return iterator to beginning"""
         return 0

{includecpp-3.7.20.dist-info → includecpp-3.7.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.20
+Version: 3.7.22
 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.20.dist-info → includecpp-3.7.22.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=4Ymntg7zK4sO2Z-sJmMHLXLI0Dqe1DbKESuvJYSZgDg,1673
+includecpp/__init__.py,sha256=I8UAmvZc1D4Tu6GT2QK0sNoj4q5i2dhrR0Isyb0tJRA,1673
 includecpp/__init__.pyi,sha256=uSDYlbqd2TinmrdepmE_zvN25jd3Co2cgyPzXgDpopM,7193
 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=AeHirETVkzNqNcqh5RVO0ABPz_6gfuV2EpHcWK9BuDY,349032
+includecpp/cli/commands.py,sha256=HDoRuPEPTzxZQcR4rF45GrRVtcw3zDj6cGiwLCZB44Y,349597
 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
@@ -21,14 +21,14 @@ includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
 includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=47sUPO-FMq_8_CrJBZFoFBgSO3gSi5zoB1Xp7oeifho,40773
 includecpp/core/cssl/__init__.py,sha256=scDXRBNK2L6A8qmlpNyaqQj6BFcSfPInBlucdeNfMF0,1975
-includecpp/core/cssl/cssl_builtins.py,sha256=6L2C_74mlVnd5C27z9LwmD5Z2jbT4wXp_QNb34cA004,89578
+includecpp/core/cssl/cssl_builtins.py,sha256=r-FX4WQeKxerkepqodIiwhtL_kxxa4PJym_WyWIwA_s,92290
 includecpp/core/cssl/cssl_builtins.pyi,sha256=3ai2V4LyhzPBhAKjRRf0rLVu_bg9ECmTfTkdFKM64iA,127430
 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=YLQUnuKwY37d1LtrJ2UMysgpAXVgIvcRQO7gUFUONts,113476
-includecpp/core/cssl/cssl_runtime.py,sha256=6wtifsRurFRm62KrdnTpzNdofl5vSOfaHM6KPXzhJVE,142036
+includecpp/core/cssl/cssl_parser.py,sha256=G9DxPLcmR7rhQvrxskp4Y8l8nXQy0tymkUVpsWWS6VM,116027
+includecpp/core/cssl/cssl_runtime.py,sha256=1z_TecgGmMjiO5RiI_eQeebToyFKZvdpbFU61b6XRUQ,152125
 includecpp/core/cssl/cssl_syntax.py,sha256=bgo3NFehoPTQa5dqwNd_CstkVGVCNYAXbGYUcu5BEN0,16982
-includecpp/core/cssl/cssl_types.py,sha256=ebgZrrddhmTRK8vQ3dNWVH15Z4rMqEx1sSmozhnJyQA,48292
+includecpp/core/cssl/cssl_types.py,sha256=gVjtfxk0Uzfj-H7_LD79oqspFMYDf79ZrRrlZk8eAEs,50647
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
 includecpp/generator/parser.cpp,sha256=hbhHdtFH65rzp6prnARN9pNFF_ssr0NseVVcxq0fJh4,76833
 includecpp/generator/parser.h,sha256=EDm0b-pEesIIIQQ2PvH5h2qwlqJU9BH8SiMV7MWbsTo,11073
@@ -43,9 +43,9 @@ includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=l4SCEPR3CsPxA8HIVLKYY__I979TfKzYWtH1KYIsboo,33062
 includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=XKRLBOHlCqDDnGPvmNHDQPsIMR1UD9PBaJIlgZOiPqM,21173
-includecpp-3.7.20.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.7.20.dist-info/METADATA,sha256=K63lr_YXZIRgYK-UUGPkwnRp4f-9JqvyJZtpibEjKFI,32122
-includecpp-3.7.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.7.20.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.7.20.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.7.20.dist-info/RECORD,,
+includecpp-3.7.22.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.7.22.dist-info/METADATA,sha256=XgO09qXzPsH5vKUtuvQ8ptcv9plaocylViuM4c4V2p0,32122
+includecpp-3.7.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.7.22.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.7.22.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.7.22.dist-info/RECORD,,