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

includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.8.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+> Version 3.8.9 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
@@ -2007,6 +2007,101 @@ class Derived : extends Base {
 }
 ```
 
+### Append Mode with `++` Operator
+
+The `++` append operator allows you to extend constructors and functions by keeping the original code and adding new code. This is useful for extending behavior without completely replacing it.
+
+#### Basic Function Append
+
+```cssl
+// Original function
+define BaseFunc() {
+    printl("Base functionality");
+}
+
+// Append to BaseFunc - keeps original + adds new
+define ExtendedFunc() &BaseFunc ++ {
+    printl("Extended functionality");
+}
+
+ExtendedFunc();
+// Output:
+// Base functionality
+// Extended functionality
+```
+
+#### Constructor Append with Class Reference
+
+```cssl
+class MyClass {
+    constr MyClassConstructor() {
+        printl("MyClass constructor");
+        this->value = 10;
+    }
+}
+
+class BetterClass :: extends MyClass {
+    // Append to specific parent constructor
+    constr BetterConstructor() &MyClass::MyClassConstructor ++ {
+        printl("BetterClass - added code");
+        this->extra = 20;
+    }
+}
+
+$instance = new BetterClass();
+// Output:
+// MyClass constructor
+// BetterClass - added code
+printl($instance.value);  // 10
+printl($instance.extra);  // 20
+```
+
+#### Method Append
+
+```cssl
+class Parent {
+    define greet() {
+        printl("Hello from Parent");
+    }
+}
+
+class Child :: extends Parent {
+    // Append to parent method
+    define betterGreet() &Parent::greet ++ {
+        printl("And also from Child!");
+    }
+}
+
+$child = new Child();
+$child.betterGreet();
+// Output:
+// Hello from Parent
+// And also from Child!
+```
+
+#### Dynamic Instance Reference
+
+You can also reference methods from instances using `&$instanceVar::member`:
+
+```cssl
+global $myInstance = new SomeClass();
+
+class Extended {
+    define extendedMethod() &$myInstance::originalMethod ++ {
+        printl("Added to instance method");
+    }
+}
+```
+
+#### Append Mode Syntax Summary
+
+| Syntax | Description |
+|--------|-------------|
+| `&FunctionName ++` | Append to a function |
+| `&ClassName::member ++` | Append to a class member (constructor/method) |
+| `&$instanceVar::member ++` | Append to an instance member |
+| `&ClassName::constructors ++` | Append to all constructors of a class |
+
 ---
 
 ## Map Container
@@ -2375,6 +2470,7 @@ print(result)  # ["Missing colon after def"]
 | `-<==` | BruteInjection | Move data |
 | `==>` | BruteInjection | Replace data |
 | `==>-` | BruteInjection | Remove matching items |
+| `++` | AppendMode | Append to parent (with `&ref`) |
 
 ### Special Syntax
 
@@ -2386,6 +2482,9 @@ print(result)  # ["Missing colon after def"]
 | `$name` | Access shared Python object |
 | `s@name` | Self-reference to struct |
 | `r@name` | Global variable declaration |
+| `&ClassName::member` | Reference class member for append mode |
+| `&$instance::member` | Reference instance member for append mode |
+| `&FunctionName ++` | Append to function (keeps old + adds new) |
 
 ---
 

includecpp/core/cssl/cssl_parser.py

@@ -110,6 +110,9 @@ class TokenType(Enum):
     EOF = auto()
     # Super-functions for .cssl-pl payload files (v3.8.0)
     SUPER_FUNC = auto()    # #$run(), #$exec(), #$printl() - pre-execution hooks
+    # Append operator for constructor/function extension
+    PLUS_PLUS = auto()     # ++ for constructor/function append (keeps old + adds new)
+    MINUS_MINUS = auto()   # -- for potential future use
 
 
 KEYWORDS = {
@@ -307,8 +310,13 @@ class CSSLLexer:
                 self._add_token(TokenType.DOT, '.')
                 self._advance()
             elif char == '+':
+                # Check for ++ (append operator for constructor/function extension)
+                if self._peek(1) == '+':
+                    self._add_token(TokenType.PLUS_PLUS, '++')
+                    self._advance()
+                    self._advance()
                 # Check for BruteForce Injection: +<== or +<<==
-                if self._peek(1) == '<' and self._peek(2) == '<' and self._peek(3) == '=' and self._peek(4) == '=':
+                elif self._peek(1) == '<' and self._peek(2) == '<' and self._peek(3) == '=' and self._peek(4) == '=':
                     self._add_token(TokenType.INFUSE_PLUS_LEFT, '+<<==')
                     for _ in range(5): self._advance()
                 elif self._peek(1) == '<' and self._peek(2) == '=' and self._peek(3) == '=':
@@ -1491,11 +1499,13 @@ class CSSLParser:
 
         Syntax:
             constr ConstructorName() { ... }
+            constr ConstructorName() ++ { ... }  // Append: keeps parent constructor + adds new code
+            constr ConstructorName() &ParentClass::constructors ++ { ... }  // Append specific parent constructor
             constr ConstructorName() : extends ParentClass::ConstructorName { ... }
             constr ConstructorName() : extends ParentClass::ConstructorName : overwrites ParentClass::ConstructorName { ... }
 
-        Multiple constructors are allowed and executed in order.
-        Constructors can access parent constructor via super().
+        The ++ operator means: execute parent's version first, then execute this code (append mode).
+        The &ClassName::member syntax references a specific member from the overwritten class.
         """
         # Get constructor name
         if not self._check(TokenType.IDENTIFIER):
@@ -1503,7 +1513,6 @@ class CSSLParser:
         constr_name = self._advance().value
 
         # Parse method-level extends/overwrites with :: syntax
-        # constr Name() :: extends Parent::Name :: overwrites Parent::Name { ... }
         extends_target = None
         extends_class_ref = None
         extends_method_ref = None
@@ -1511,12 +1520,39 @@ class CSSLParser:
         overwrites_class_ref = None
         overwrites_method_ref = None
 
+        # New: Append mode and reference tracking
+        append_mode = False  # ++ operator: keep parent code + add new
+        append_ref_class = None  # &ClassName part
+        append_ref_member = None  # ::member part (constructors, functionName, etc.)
+
         # Parse parameters
         params = []
         if self._match(TokenType.PAREN_START):
             params = self._parse_parameter_list()
             self._expect(TokenType.PAREN_END)
 
+        # Check for &ClassName::member reference (for targeting specific parent member)
+        # Syntax: constr Name() &ParentClass::constructors ++ { ... }
+        if self._match(TokenType.AMPERSAND):
+            # Parse the class reference
+            if self._check(TokenType.IDENTIFIER):
+                append_ref_class = self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+            else:
+                raise CSSLSyntaxError("Expected class name after '&' in constructor reference")
+
+            # Check for ::member
+            if self._match(TokenType.DOUBLE_COLON):
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    append_ref_member = self._advance().value
+                else:
+                    raise CSSLSyntaxError("Expected member name after '::' in constructor reference")
+
+        # Check for ++ append operator
+        if self._match(TokenType.PLUS_PLUS):
+            append_mode = True
+
         # Check for method-level extends/overwrites with :: or :
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             while True:
@@ -1563,7 +1599,11 @@ class CSSLParser:
             'extends_method': extends_method_ref,
             'overwrites_target': overwrites_target,
             'overwrites_class': overwrites_class_ref,
-            'overwrites_method': overwrites_method_ref
+            'overwrites_method': overwrites_method_ref,
+            # New append mode fields
+            'append_mode': append_mode,
+            'append_ref_class': append_ref_class,
+            'append_ref_member': append_ref_member
         }, children=body)
 
     def _parse_qualified_method_ref(self) -> str:
@@ -1769,6 +1809,32 @@ class CSSLParser:
                     break
             self._expect(TokenType.PAREN_END)
 
+        # New: Append mode and reference tracking for functions
+        # Syntax: define XYZ(int zahl) &overwrittenclass::functionyouwanttokeep ++ { ... }
+        append_mode = False
+        append_ref_class = None
+        append_ref_member = None
+
+        # Check for &ClassName::member reference
+        if self._match(TokenType.AMPERSAND):
+            if self._check(TokenType.IDENTIFIER):
+                append_ref_class = self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+            else:
+                raise CSSLSyntaxError("Expected class name after '&' in function reference")
+
+            # Check for ::member
+            if self._match(TokenType.DOUBLE_COLON):
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    append_ref_member = self._advance().value
+                else:
+                    raise CSSLSyntaxError("Expected member name after '::' in function reference")
+
+        # Check for ++ append operator
+        if self._match(TokenType.PLUS_PLUS):
+            append_mode = True
+
         node = ASTNode('function', value={
             'name': name,
             'params': params,
@@ -1781,7 +1847,11 @@ class CSSLParser:
             'extends_class': extends_class_ref,
             'extends_method': extends_method_ref,
             'overwrites_class': overwrites_class_ref,
-            'overwrites_method': overwrites_method_ref
+            'overwrites_method': overwrites_method_ref,
+            # New append mode fields
+            'append_mode': append_mode,
+            'append_ref_class': append_ref_class,
+            'append_ref_member': append_ref_member
         }, children=[])
         self._expect(TokenType.BLOCK_START)
 

includecpp/core/cssl/cssl_runtime.py

@@ -1290,6 +1290,17 @@ class CSSLRuntime:
         self.scope = new_scope
 
         try:
+            # Handle append mode (++) - execute referenced function first
+            append_mode = func_info.get('append_mode', False)
+            append_ref_class = func_info.get('append_ref_class')
+            append_ref_member = func_info.get('append_ref_member')
+
+            if append_mode and append_ref_class:
+                self._execute_append_reference(
+                    None, append_ref_class, append_ref_member,
+                    args, kwargs, {}, is_constructor=False
+                )
+
             for child in func_node.children:
                 # Check if exit() was called
                 if not self._running:
@@ -3271,17 +3282,122 @@ class CSSLRuntime:
             except TypeError:
                 pass
 
+    def _execute_append_reference(self, instance: CSSLInstance, ref_class: str, ref_member: str,
+                                   args: list, kwargs: dict, param_values: dict, is_constructor: bool = True):
+        """Execute referenced parent constructor/method for append mode (++).
+
+        Resolves the class/instance reference and executes the specified member.
+        Supports:
+        - Static class references: &ClassName::member
+        - Dynamic instance references: &$instanceVar::member
+        - Direct function references: &FunctionName (for define functions)
+
+        Args:
+            instance: Current class instance (can be None for standalone functions)
+            ref_class: Referenced class name, $instanceVar, or function name
+            ref_member: Member name (constructor name, 'constructors', or method name) - can be None
+            args: Arguments to pass
+            kwargs: Keyword arguments to pass
+            param_values: Parameter values from class params
+            is_constructor: True if looking for constructor, False for method
+        """
+        from .cssl_builtins import CSSLizedPythonObject
+
+        # Handle direct function reference: &FunctionName ++ (no ::member part)
+        if ref_member is None and not is_constructor:
+            # ref_class is actually a function name
+            func_name = ref_class
+            if func_name.startswith('$'):
+                func_name = func_name[1:]
+
+            # Look for the function in scope
+            func = self.scope.get(func_name) or self.global_scope.get(func_name)
+            if func is not None:
+                if isinstance(func, ASTNode) and func.type in ('function', 'FUNCTION'):
+                    # Execute the referenced function
+                    if instance:
+                        self._call_method(instance, func, args, kwargs)
+                    else:
+                        self._call_function(func, args, kwargs)
+                elif callable(func):
+                    # It's a callable (Python function or lambda)
+                    func(*args, **kwargs)
+            return
+
+        # Resolve the class/instance reference
+        if ref_class.startswith('$'):
+            # Dynamic instance reference: &$instanceVar::member
+            var_name = ref_class[1:]
+            ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+            if ref_obj is None:
+                return  # Instance not found, skip silently
+
+            if isinstance(ref_obj, CSSLInstance):
+                # Get the class definition from the instance
+                target_class = ref_obj.class_def
+            elif isinstance(ref_obj, CSSLClass):
+                target_class = ref_obj
+            else:
+                return  # Not a valid reference
+        else:
+            # Static class reference: &ClassName::member
+            target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+
+        if target_class is None:
+            return  # Class not found, skip silently
+
+        # Handle different target types
+        if isinstance(target_class, CSSLInstance):
+            # Referenced an instance variable directly
+            target_class = target_class.class_def
+
+        if not isinstance(target_class, CSSLClass):
+            return  # Not a CSSL class
+
+        # Find and execute the referenced member
+        if is_constructor:
+            # Looking for a constructor
+            if ref_member == 'constructors' or ref_member is None:
+                # Execute all constructors from the referenced class
+                for constr in getattr(target_class, 'constructors', []):
+                    self._call_constructor(instance, constr, args, kwargs, param_values)
+            else:
+                # Execute specific constructor by name
+                for constr in getattr(target_class, 'constructors', []):
+                    if constr.value.get('name') == ref_member:
+                        self._call_constructor(instance, constr, args, kwargs, param_values)
+                        break
+        else:
+            # Looking for a method (define function)
+            if ref_member:
+                # Find method in class
+                for member in getattr(target_class, 'members', []):
+                    if member.type in ('function', 'FUNCTION') and member.value.get('name') == ref_member:
+                        self._call_method(instance, member, args, kwargs)
+                        break
+                # Also check in methods dict if available
+                methods = getattr(target_class, 'methods', {})
+                if ref_member in methods:
+                    method_node = methods[ref_member]
+                    self._call_method(instance, method_node, args, kwargs)
+
     def _call_constructor(self, instance: CSSLInstance, constr_node: ASTNode,
                           args: list, kwargs: dict, param_values: dict):
         """Call a constructor defined with 'constr' keyword.
 
         Handles constructor extends/overwrites and sets up the instance scope.
+        Supports append mode (++) for keeping parent code and adding new code.
         """
         constr_info = constr_node.value
         constr_params = constr_info.get('params', [])
         extends_class = constr_info.get('extends_class')
         extends_method = constr_info.get('extends_method')
 
+        # Append mode: ++ operator for keeping parent code + adding new
+        append_mode = constr_info.get('append_mode', False)
+        append_ref_class = constr_info.get('append_ref_class')  # &ClassName or &$instanceVar
+        append_ref_member = constr_info.get('append_ref_member')  # ::constructorName or ::methodName
+
         # Save previous instance context
         prev_instance = self._current_instance
         self._current_instance = instance
@@ -3313,6 +3429,13 @@ class CSSLRuntime:
                         self._call_constructor(instance, constr, args, kwargs, param_values)
                         break
 
+        # Handle append mode (++) - execute referenced parent member first
+        if append_mode and append_ref_class:
+            self._execute_append_reference(
+                instance, append_ref_class, append_ref_member,
+                args, kwargs, param_values, is_constructor=True
+            )
+
         # Execute constructor body
         prev_scope = self.scope
         self.scope = new_scope
@@ -3376,12 +3499,18 @@ class CSSLRuntime:
         """Call a method on an instance with 'this' context.
 
         Sets up the instance as the current 'this' context and executes the method.
+        Supports append mode (++) for keeping parent code and adding new code.
         """
         kwargs = kwargs or {}
         func_info = method_node.value
         params = func_info.get('params', [])
         modifiers = func_info.get('modifiers', [])
 
+        # Append mode: ++ operator for keeping parent code + adding new
+        append_mode = func_info.get('append_mode', False)
+        append_ref_class = func_info.get('append_ref_class')  # &ClassName or &$instanceVar
+        append_ref_member = func_info.get('append_ref_member')  # ::methodName
+
         # Check for undefined modifier
         is_undefined = 'undefined' in modifiers
 
@@ -3408,6 +3537,13 @@ class CSSLRuntime:
         self._current_instance = instance
 
         try:
+            # Handle append mode (++) - execute referenced parent method first
+            if append_mode and append_ref_class:
+                self._execute_append_reference(
+                    instance, append_ref_class, append_ref_member,
+                    args, kwargs, {}, is_constructor=False
+                )
+
             for child in method_node.children:
                 if not self._running:
                     break

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

@@ -7,6 +7,8 @@
         { "include": "#comments" },
         { "include": "#strings" },
         { "include": "#numbers" },
+        { "include": "#append-operator" },
+        { "include": "#append-reference" },
         { "include": "#class-definition" },
         { "include": "#function-definitions" },
         { "include": "#constructor-definition" },
@@ -35,6 +37,29 @@
         { "include": "#variables" }
     ],
     "repository": {
+        "append-operator": {
+            "patterns": [
+                {
+                    "comment": "++ append operator for constructor/function extension - orange",
+                    "name": "constant.character.escape.infuse.cssl",
+                    "match": "\\+\\+(?=\\s*\\{)"
+                }
+            ]
+        },
+        "append-reference": {
+            "patterns": [
+                {
+                    "comment": "&ClassName::member or &$var::member - all yellow for append reference",
+                    "name": "entity.name.tag.super.cssl",
+                    "match": "&(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(::)([a-zA-Z_][a-zA-Z0-9_]*)"
+                },
+                {
+                    "comment": "&FunctionName - yellow for direct function reference",
+                    "name": "entity.name.tag.super.cssl",
+                    "match": "&([a-zA-Z_][a-zA-Z0-9_]*)(?=\\s*\\+\\+)"
+                }
+            ]
+        },
         "non-null-declarations": {
             "patterns": [
                 {

{includecpp-3.8.8.dist-info → includecpp-3.8.9.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-includecpp/__init__.py,sha256=XmL_pnk_lOdqLw9gz6GfffxGKt1ea79WjLE-G_myEwI,1672
+includecpp/__init__.py,sha256=bKXVpFFAmREaA5tWkovN7kfgZV0Pv18AJZBwMP1Gwi0,1672
 includecpp/__init__.pyi,sha256=uSDYlbqd2TinmrdepmE_zvN25jd3Co2cgyPzXgDpopM,7193
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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=UF2RpPyuUWrU08E49t19OcsGModkwlRvajDWifCxqFo,48051
+includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=ffeW2QwWCcZLB_Sx583imqaSeo4DpPun_c2E43eTnYw,50536
 includecpp/core/cssl/__init__.py,sha256=scDXRBNK2L6A8qmlpNyaqQj6BFcSfPInBlucdeNfMF0,1975
 includecpp/core/cssl/cssl_builtins.py,sha256=oPsPyQk5b0b1I02Y80oIaDX39GOeG32-nBPEqwbo_Pw,105110
 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=4e2qXFmnc6bw4dEQsuOJpJHEVjZLxWLA0BOvgk8F9-Y,136619
-includecpp/core/cssl/cssl_runtime.py,sha256=e_4XnjS2CkDhEdXb9P9lt3wxrQrcfZeGCIp4d1smTLA,177848
+includecpp/core/cssl/cssl_parser.py,sha256=BGS_rGZ2Jh7bp3JmUL-h-Jed_pTtNFMomLKB2P6qklQ,140173
+includecpp/core/cssl/cssl_runtime.py,sha256=nub0UA4wtjhYPDQ61Jq6UKH1pVqwH3I7yb-Gmz7fWM0,184679
 includecpp/core/cssl/cssl_syntax.py,sha256=bgo3NFehoPTQa5dqwNd_CstkVGVCNYAXbGYUcu5BEN0,16982
 includecpp/core/cssl/cssl_types.py,sha256=7jbrtZf3xmVQJA_mnL9iYrmdjhjuc4--mxxNigi7fsk,53425
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
@@ -43,10 +43,10 @@ includecpp/vscode/cssl/package.json,sha256=5MCJts7zYIgF8EdWcBnn98deIMyZamlGXvt1a
 includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86MsvUGlSZw,510
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=uV3nHJyQ5f7Pr3FzfbQT2VZOEY3AlGs4wrmqe884jm4,37372
-includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=l62jwXdjMx7-awg5X9WNBrGs4m34uP8W1CV7U7cpP4Y,34004
-includecpp-3.8.8.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.8.8.dist-info/METADATA,sha256=lytD7GrK-26_ShDT7te-HvWJf8EupZ7i9hnlCM7OUUs,22510
-includecpp-3.8.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.8.8.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.8.8.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.8.8.dist-info/RECORD,,
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=FZw1_VDz1ll4ZBZeGqo-935CK5RuF2kD75rNp5tVdC0,35068
+includecpp-3.8.9.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.8.9.dist-info/METADATA,sha256=fKlj1rXZq7nbfWOdJn0iZtDcFRlr9tj0hHZQqdPksnI,22510
+includecpp-3.8.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.8.9.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.8.9.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.8.9.dist-info/RECORD,,