IncludeCPP 3.7.3__py3-none-any.whl

includecpp/vscode/cssl/snippets/cssl.snippets.json

@@ -0,0 +1,1080 @@
+{
+    "Class Definition": {
+        "prefix": ["class", "cls"],
+        "body": [
+            "class ${1:ClassName} {",
+            "\t// Member variables",
+            "\t${2:string} ${3:name};",
+            "",
+            "\t// Constructor",
+            "\tvoid ${1}(${4:params}) {",
+            "\t\tthis->${3} = ${5:value};",
+            "\t}",
+            "",
+            "\t// Methods",
+            "\t${6:void} ${7:methodName}() {",
+            "\t\t$0",
+            "\t}",
+            "}"
+        ],
+        "description": "Create a new CSSL class with constructor and method"
+    },
+    "Constructor": {
+        "prefix": ["constructor", "ctor"],
+        "body": [
+            "void ${1:ClassName}(${2:params}) {",
+            "\tthis->${3:member} = ${4:value};$0",
+            "}"
+        ],
+        "description": "Create a class constructor"
+    },
+    "New Instance": {
+        "prefix": ["new", "instance"],
+        "body": [
+            "${1:ClassName} ${2:obj} = new ${1}(${3:args});$0"
+        ],
+        "description": "Create new class instance"
+    },
+    "This Access": {
+        "prefix": ["this->", "this"],
+        "body": [
+            "this->${1:member}$0"
+        ],
+        "description": "Access class member with this->"
+    },
+    "Function Definition": {
+        "prefix": ["func", "function", "define"],
+        "body": [
+            "${1:void} ${2:functionName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Create a function"
+    },
+    "If Statement": {
+        "prefix": "if",
+        "body": [
+            "if (${1:condition}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "If statement"
+    },
+    "If-Else Statement": {
+        "prefix": "ife",
+        "body": [
+            "if (${1:condition}) {",
+            "\t$2",
+            "} else {",
+            "\t$0",
+            "}"
+        ],
+        "description": "If-else statement"
+    },
+    "For Loop": {
+        "prefix": "for",
+        "body": [
+            "for (int ${1:i} = 0; ${1} < ${2:count}; ${1}++) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "For loop"
+    },
+    "Foreach Loop": {
+        "prefix": "foreach",
+        "body": [
+            "foreach (${1:item} in ${2:collection}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Foreach loop"
+    },
+    "While Loop": {
+        "prefix": "while",
+        "body": [
+            "while (${1:condition}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "While loop"
+    },
+    "Try-Catch": {
+        "prefix": "try",
+        "body": [
+            "try {",
+            "\t$1",
+            "} catch {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Try-catch block"
+    },
+    "Switch Statement": {
+        "prefix": "switch",
+        "body": [
+            "switch (${1:expression}) {",
+            "\tcase ${2:value}:",
+            "\t\t$3",
+            "\t\tbreak;",
+            "\tdefault:",
+            "\t\t$0",
+            "}"
+        ],
+        "description": "Switch statement"
+    },
+    "Main Function": {
+        "prefix": "main",
+        "body": [
+            "void main() {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Main function entry point"
+    },
+
+    "Print": {
+        "prefix": "print",
+        "body": "print(${1:value});$0",
+        "description": "Print values without newline"
+    },
+    "Print Line": {
+        "prefix": ["printl", "pl", "println"],
+        "body": "printl(${1:\"message\"});$0",
+        "description": "Print values with newline"
+    },
+    "Debug": {
+        "prefix": "debug",
+        "body": "debug(${1:value});$0",
+        "description": "Print debug information with [DEBUG] prefix"
+    },
+    "Error": {
+        "prefix": "error",
+        "body": "error(${1:\"error message\"});$0",
+        "description": "Print error message with [ERROR] prefix"
+    },
+    "Warn": {
+        "prefix": "warn",
+        "body": "warn(${1:\"warning message\"});$0",
+        "description": "Print warning message with [WARN] prefix"
+    },
+
+    "Int Conversion": {
+        "prefix": "int(",
+        "body": "int(${1:value})$0",
+        "description": "Convert value to integer"
+    },
+    "Float Conversion": {
+        "prefix": "float(",
+        "body": "float(${1:value})$0",
+        "description": "Convert value to float"
+    },
+    "String Conversion": {
+        "prefix": "str(",
+        "body": "str(${1:value})$0",
+        "description": "Convert value to string"
+    },
+    "Bool Conversion": {
+        "prefix": "bool(",
+        "body": "bool(${1:value})$0",
+        "description": "Convert value to boolean"
+    },
+    "List Conversion": {
+        "prefix": "list(",
+        "body": "list(${1:value})$0",
+        "description": "Convert value to list or create empty list"
+    },
+    "Dict Conversion": {
+        "prefix": "dict(",
+        "body": "dict(${1:value})$0",
+        "description": "Convert value to dictionary"
+    },
+
+    "Typeof": {
+        "prefix": "typeof",
+        "body": "typeof(${1:value})$0",
+        "description": "Get type name of value (int, str, list, etc.)"
+    },
+    "Isinstance": {
+        "prefix": "isinstance",
+        "body": "isinstance(${1:value}, ${2:\"type\"})$0",
+        "description": "Check if value is instance of type"
+    },
+    "Isint": {
+        "prefix": "isint",
+        "body": "isint(${1:value})$0",
+        "description": "Check if value is an integer"
+    },
+    "Isfloat": {
+        "prefix": "isfloat",
+        "body": "isfloat(${1:value})$0",
+        "description": "Check if value is a float"
+    },
+    "Isstr": {
+        "prefix": "isstr",
+        "body": "isstr(${1:value})$0",
+        "description": "Check if value is a string"
+    },
+    "Isbool": {
+        "prefix": "isbool",
+        "body": "isbool(${1:value})$0",
+        "description": "Check if value is a boolean"
+    },
+    "Islist": {
+        "prefix": "islist",
+        "body": "islist(${1:value})$0",
+        "description": "Check if value is a list"
+    },
+    "Isdict": {
+        "prefix": "isdict",
+        "body": "isdict(${1:value})$0",
+        "description": "Check if value is a dictionary"
+    },
+    "Isnull": {
+        "prefix": "isnull",
+        "body": "isnull(${1:value})$0",
+        "description": "Check if value is null"
+    },
+
+    "Len": {
+        "prefix": "len",
+        "body": "len(${1:value})$0",
+        "description": "Get length of string, list, or dictionary"
+    },
+    "Upper": {
+        "prefix": "upper",
+        "body": "upper(${1:string})$0",
+        "description": "Convert string to uppercase"
+    },
+    "Lower": {
+        "prefix": "lower",
+        "body": "lower(${1:string})$0",
+        "description": "Convert string to lowercase"
+    },
+    "Trim": {
+        "prefix": "trim",
+        "body": "trim(${1:string})$0",
+        "description": "Remove whitespace from both ends"
+    },
+    "Ltrim": {
+        "prefix": "ltrim",
+        "body": "ltrim(${1:string})$0",
+        "description": "Remove whitespace from left side"
+    },
+    "Rtrim": {
+        "prefix": "rtrim",
+        "body": "rtrim(${1:string})$0",
+        "description": "Remove whitespace from right side"
+    },
+    "Split": {
+        "prefix": "split",
+        "body": "split(${1:string}, ${2:\",\"})$0",
+        "description": "Split string into list by delimiter"
+    },
+    "Join": {
+        "prefix": "join",
+        "body": "join(${1:array}, ${2:\"-\"})$0",
+        "description": "Join list elements into string"
+    },
+    "Replace": {
+        "prefix": "replace",
+        "body": "replace(${1:string}, ${2:\"old\"}, ${3:\"new\"})$0",
+        "description": "Replace all occurrences of substring"
+    },
+    "Substr": {
+        "prefix": "substr",
+        "body": "substr(${1:string}, ${2:start}, ${3:length})$0",
+        "description": "Extract substring"
+    },
+    "Contains": {
+        "prefix": "contains",
+        "body": "contains(${1:string}, ${2:\"substring\"})$0",
+        "description": "Check if string contains substring"
+    },
+    "Startswith": {
+        "prefix": "startswith",
+        "body": "startswith(${1:string}, ${2:\"prefix\"})$0",
+        "description": "Check if string starts with prefix"
+    },
+    "Endswith": {
+        "prefix": "endswith",
+        "body": "endswith(${1:string}, ${2:\"suffix\"})$0",
+        "description": "Check if string ends with suffix"
+    },
+    "Format": {
+        "prefix": "format",
+        "body": "format(${1:\"template {}\"}, ${2:value})$0",
+        "description": "Format string with placeholders"
+    },
+    "Concat": {
+        "prefix": "concat",
+        "body": "concat(${1:\"a\"}, ${2:\"b\"})$0",
+        "description": "Concatenate multiple strings"
+    },
+    "Repeat": {
+        "prefix": "repeat",
+        "body": "repeat(${1:string}, ${2:count})$0",
+        "description": "Repeat string n times"
+    },
+    "Reverse": {
+        "prefix": "reverse",
+        "body": "reverse(${1:string})$0",
+        "description": "Reverse string"
+    },
+    "Indexof": {
+        "prefix": "indexof",
+        "body": "indexof(${1:string}, ${2:\"substring\"})$0",
+        "description": "Find first occurrence of substring"
+    },
+    "Lastindexof": {
+        "prefix": "lastindexof",
+        "body": "lastindexof(${1:string}, ${2:\"substring\"})$0",
+        "description": "Find last occurrence of substring"
+    },
+    "Padleft": {
+        "prefix": "padleft",
+        "body": "padleft(${1:string}, ${2:length}, ${3:\"0\"})$0",
+        "description": "Pad string on left to specified length"
+    },
+    "Padright": {
+        "prefix": "padright",
+        "body": "padright(${1:string}, ${2:length}, ${3:\"0\"})$0",
+        "description": "Pad string on right to specified length"
+    },
+    "Capitalize": {
+        "prefix": "capitalize",
+        "body": "capitalize(${1:string})$0",
+        "description": "Capitalize first character"
+    },
+    "Title": {
+        "prefix": "title",
+        "body": "title(${1:string})$0",
+        "description": "Capitalize first character of each word"
+    },
+
+    "Push": {
+        "prefix": "push",
+        "body": "push(${1:array}, ${2:value});$0",
+        "description": "Add element to end of array"
+    },
+    "Pop": {
+        "prefix": "pop",
+        "body": "pop(${1:array})$0",
+        "description": "Remove and return last element"
+    },
+    "Shift": {
+        "prefix": "shift",
+        "body": "shift(${1:array})$0",
+        "description": "Remove and return first element"
+    },
+    "Unshift": {
+        "prefix": "unshift",
+        "body": "unshift(${1:array}, ${2:value});$0",
+        "description": "Add element to beginning of array"
+    },
+    "Slice": {
+        "prefix": "slice",
+        "body": "slice(${1:array}, ${2:start}, ${3:end})$0",
+        "description": "Extract portion of array"
+    },
+    "Sort": {
+        "prefix": "sort",
+        "body": "sort(${1:array})$0",
+        "description": "Sort array in ascending order"
+    },
+    "Rsort": {
+        "prefix": "rsort",
+        "body": "rsort(${1:array})$0",
+        "description": "Sort array in descending order"
+    },
+    "Unique": {
+        "prefix": "unique",
+        "body": "unique(${1:array})$0",
+        "description": "Remove duplicate elements"
+    },
+    "Flatten": {
+        "prefix": "flatten",
+        "body": "flatten(${1:array})$0",
+        "description": "Flatten nested arrays"
+    },
+    "Filter": {
+        "prefix": "filter",
+        "body": "filter(${1:array}, ${2:predicate})$0",
+        "description": "Filter array by predicate function"
+    },
+    "Map Function": {
+        "prefix": "map(",
+        "body": "map(${1:array}, ${2:func})$0",
+        "description": "Apply function to each element"
+    },
+    "Reduce": {
+        "prefix": "reduce",
+        "body": "reduce(${1:array}, ${2:func}, ${3:initial})$0",
+        "description": "Reduce array to single value"
+    },
+    "Find": {
+        "prefix": "find",
+        "body": "find(${1:array}, ${2:predicate})$0",
+        "description": "Find first element matching predicate"
+    },
+    "Findindex": {
+        "prefix": "findindex",
+        "body": "findindex(${1:array}, ${2:predicate})$0",
+        "description": "Find index of first matching element"
+    },
+    "Range": {
+        "prefix": "range",
+        "body": "range(${1:start}, ${2:stop}, ${3:step})$0",
+        "description": "Generate range of integers"
+    },
+
+    "Keys": {
+        "prefix": "keys",
+        "body": "keys(${1:dict})$0",
+        "description": "Get all dictionary keys"
+    },
+    "Values": {
+        "prefix": "values",
+        "body": "values(${1:dict})$0",
+        "description": "Get all dictionary values"
+    },
+    "Items": {
+        "prefix": "items",
+        "body": "items(${1:dict})$0",
+        "description": "Get all key-value pairs"
+    },
+    "Haskey": {
+        "prefix": "haskey",
+        "body": "haskey(${1:dict}, ${2:\"key\"})$0",
+        "description": "Check if dictionary has key"
+    },
+    "Getkey": {
+        "prefix": "getkey",
+        "body": "getkey(${1:dict}, ${2:\"key\"}, ${3:default})$0",
+        "description": "Get value by key with optional default"
+    },
+    "Setkey": {
+        "prefix": "setkey",
+        "body": "setkey(${1:dict}, ${2:\"key\"}, ${3:value});$0",
+        "description": "Set key-value pair in dictionary"
+    },
+    "Delkey": {
+        "prefix": "delkey",
+        "body": "delkey(${1:dict}, ${2:\"key\"});$0",
+        "description": "Delete key from dictionary"
+    },
+    "Merge": {
+        "prefix": "merge",
+        "body": "merge(${1:dict1}, ${2:dict2})$0",
+        "description": "Merge multiple dictionaries"
+    },
+
+    "Abs": {
+        "prefix": "abs",
+        "body": "abs(${1:value})$0",
+        "description": "Absolute value"
+    },
+    "Min": {
+        "prefix": "min",
+        "body": "min(${1:values})$0",
+        "description": "Minimum value"
+    },
+    "Max": {
+        "prefix": "max",
+        "body": "max(${1:values})$0",
+        "description": "Maximum value"
+    },
+    "Sum": {
+        "prefix": "sum",
+        "body": "sum(${1:array})$0",
+        "description": "Sum of array elements"
+    },
+    "Avg": {
+        "prefix": "avg",
+        "body": "avg(${1:array})$0",
+        "description": "Average of array elements"
+    },
+    "Round": {
+        "prefix": "round",
+        "body": "round(${1:value}, ${2:decimals})$0",
+        "description": "Round to specified decimal places"
+    },
+    "Floor": {
+        "prefix": "floor",
+        "body": "floor(${1:value})$0",
+        "description": "Round down to nearest integer"
+    },
+    "Ceil": {
+        "prefix": "ceil",
+        "body": "ceil(${1:value})$0",
+        "description": "Round up to nearest integer"
+    },
+    "Pow": {
+        "prefix": "pow",
+        "body": "pow(${1:base}, ${2:exponent})$0",
+        "description": "Raise base to power"
+    },
+    "Sqrt": {
+        "prefix": "sqrt",
+        "body": "sqrt(${1:value})$0",
+        "description": "Square root"
+    },
+    "Random": {
+        "prefix": "random",
+        "body": "random()$0",
+        "description": "Random float between 0 and 1"
+    },
+    "Randint": {
+        "prefix": "randint",
+        "body": "randint(${1:min}, ${2:max})$0",
+        "description": "Random integer in range [min, max]"
+    },
+    "Sin": {
+        "prefix": "sin",
+        "body": "sin(${1:radians})$0",
+        "description": "Sine (radians)"
+    },
+    "Cos": {
+        "prefix": "cos",
+        "body": "cos(${1:radians})$0",
+        "description": "Cosine (radians)"
+    },
+    "Tan": {
+        "prefix": "tan",
+        "body": "tan(${1:radians})$0",
+        "description": "Tangent (radians)"
+    },
+    "Asin": {
+        "prefix": "asin",
+        "body": "asin(${1:value})$0",
+        "description": "Arc sine (returns radians)"
+    },
+    "Acos": {
+        "prefix": "acos",
+        "body": "acos(${1:value})$0",
+        "description": "Arc cosine (returns radians)"
+    },
+    "Atan": {
+        "prefix": "atan",
+        "body": "atan(${1:value})$0",
+        "description": "Arc tangent (returns radians)"
+    },
+    "Atan2": {
+        "prefix": "atan2",
+        "body": "atan2(${1:y}, ${2:x})$0",
+        "description": "Two-argument arc tangent"
+    },
+    "Log": {
+        "prefix": "log",
+        "body": "log(${1:value})$0",
+        "description": "Natural logarithm"
+    },
+    "Log10": {
+        "prefix": "log10",
+        "body": "log10(${1:value})$0",
+        "description": "Base-10 logarithm"
+    },
+    "Exp": {
+        "prefix": "exp",
+        "body": "exp(${1:value})$0",
+        "description": "Exponential function (e^x)"
+    },
+    "Pi": {
+        "prefix": "pi",
+        "body": "pi()$0",
+        "description": "Mathematical constant pi (3.14159...)"
+    },
+    "E Constant": {
+        "prefix": "e()",
+        "body": "e()$0",
+        "description": "Mathematical constant e (2.71828...)"
+    },
+    "Radians": {
+        "prefix": "radians",
+        "body": "radians(${1:degrees})$0",
+        "description": "Convert degrees to radians"
+    },
+    "Degrees": {
+        "prefix": "degrees",
+        "body": "degrees(${1:radians})$0",
+        "description": "Convert radians to degrees"
+    },
+
+    "Now": {
+        "prefix": "now",
+        "body": "now()$0",
+        "description": "Current timestamp as float"
+    },
+    "Timestamp": {
+        "prefix": "timestamp",
+        "body": "timestamp()$0",
+        "description": "Current timestamp as integer"
+    },
+    "Sleep": {
+        "prefix": "sleep",
+        "body": "sleep(${1:seconds});$0",
+        "description": "Pause execution for specified seconds"
+    },
+    "Date": {
+        "prefix": "date",
+        "body": "date(${1:\"%Y-%m-%d\"})$0",
+        "description": "Current date as formatted string"
+    },
+    "Time": {
+        "prefix": "time",
+        "body": "time(${1:\"%H:%M:%S\"})$0",
+        "description": "Current time as formatted string"
+    },
+    "Datetime": {
+        "prefix": "datetime",
+        "body": "datetime(${1:\"%Y-%m-%d %H:%M:%S\"})$0",
+        "description": "Current date and time"
+    },
+    "Strftime": {
+        "prefix": "strftime",
+        "body": "strftime(${1:\"%Y-%m-%d\"}, ${2:timestamp})$0",
+        "description": "Format timestamp as string"
+    },
+
+    "Read File": {
+        "prefix": "read",
+        "body": "read(${1:\"path\"})$0",
+        "description": "Read entire file content"
+    },
+    "Readline": {
+        "prefix": "readline",
+        "body": "readline(${1:line}, ${2:\"path\"})$0",
+        "description": "Read specific line from file (1-indexed)"
+    },
+    "Write File": {
+        "prefix": "write",
+        "body": "write(${1:\"path\"}, ${2:content});$0",
+        "description": "Write content to file (overwrites)"
+    },
+    "Writeline": {
+        "prefix": "writeline",
+        "body": "writeline(${1:line}, ${2:content}, ${3:\"path\"});$0",
+        "description": "Write/replace specific line in file"
+    },
+    "Appendfile": {
+        "prefix": "appendfile",
+        "body": "appendfile(${1:\"path\"}, ${2:content});$0",
+        "description": "Append content to file"
+    },
+    "Readlines": {
+        "prefix": "readlines",
+        "body": "readlines(${1:\"path\"})$0",
+        "description": "Read all lines from file"
+    },
+    "Pathexists": {
+        "prefix": "pathexists",
+        "body": "pathexists(${1:\"path\"})$0",
+        "description": "Check if path exists"
+    },
+    "Isfile": {
+        "prefix": "isfile",
+        "body": "isfile(${1:\"path\"})$0",
+        "description": "Check if path is a file"
+    },
+    "Isdir": {
+        "prefix": "isdir",
+        "body": "isdir(${1:\"path\"})$0",
+        "description": "Check if path is a directory"
+    },
+    "Listdir": {
+        "prefix": "listdir",
+        "body": "listdir(${1:\"path\"})$0",
+        "description": "List directory contents"
+    },
+    "Makedirs": {
+        "prefix": "makedirs",
+        "body": "makedirs(${1:\"path\"});$0",
+        "description": "Create directory and parent directories"
+    },
+    "Removefile": {
+        "prefix": "removefile",
+        "body": "removefile(${1:\"path\"});$0",
+        "description": "Delete a file"
+    },
+    "Removedir": {
+        "prefix": "removedir",
+        "body": "removedir(${1:\"path\"});$0",
+        "description": "Delete an empty directory"
+    },
+    "Copyfile": {
+        "prefix": "copyfile",
+        "body": "copyfile(${1:\"src\"}, ${2:\"dst\"});$0",
+        "description": "Copy file from source to destination"
+    },
+    "Movefile": {
+        "prefix": "movefile",
+        "body": "movefile(${1:\"src\"}, ${2:\"dst\"});$0",
+        "description": "Move/rename file"
+    },
+    "Filesize": {
+        "prefix": "filesize",
+        "body": "filesize(${1:\"path\"})$0",
+        "description": "Get file size in bytes"
+    },
+    "Basename": {
+        "prefix": "basename",
+        "body": "basename(${1:\"path\"})$0",
+        "description": "Get filename from path"
+    },
+    "Dirname": {
+        "prefix": "dirname",
+        "body": "dirname(${1:\"path\"})$0",
+        "description": "Get directory from path"
+    },
+    "Joinpath": {
+        "prefix": "joinpath",
+        "body": "joinpath(${1:\"path1\"}, ${2:\"path2\"})$0",
+        "description": "Join path components"
+    },
+    "Abspath": {
+        "prefix": "abspath",
+        "body": "abspath(${1:\"path\"})$0",
+        "description": "Get absolute path"
+    },
+
+    "JSON Read": {
+        "prefix": "json::read",
+        "body": "json::read(${1:\"path\"})$0",
+        "description": "Read and parse JSON file"
+    },
+    "JSON Write": {
+        "prefix": "json::write",
+        "body": "json::write(${1:\"path\"}, ${2:data});$0",
+        "description": "Write data to JSON file"
+    },
+    "JSON Parse": {
+        "prefix": "json::parse",
+        "body": "json::parse(${1:jsonString})$0",
+        "description": "Parse JSON string"
+    },
+    "JSON Stringify": {
+        "prefix": "json::stringify",
+        "body": "json::stringify(${1:data})$0",
+        "description": "Convert data to JSON string"
+    },
+    "JSON Pretty": {
+        "prefix": "json::pretty",
+        "body": "json::pretty(${1:data})$0",
+        "description": "Pretty print JSON with indentation"
+    },
+    "JSON Get": {
+        "prefix": "json::get",
+        "body": "json::get(${1:data}, ${2:\"path.to.key\"})$0",
+        "description": "Get value by dot-path"
+    },
+    "JSON Set": {
+        "prefix": "json::set",
+        "body": "json::set(${1:data}, ${2:\"path.to.key\"}, ${3:value})$0",
+        "description": "Set value by dot-path"
+    },
+    "JSON Has": {
+        "prefix": "json::has",
+        "body": "json::has(${1:data}, ${2:\"path.to.key\"})$0",
+        "description": "Check if path exists"
+    },
+    "JSON Keys": {
+        "prefix": "json::keys",
+        "body": "json::keys(${1:data})$0",
+        "description": "Get all keys from JSON object"
+    },
+    "JSON Values": {
+        "prefix": "json::values",
+        "body": "json::values(${1:data})$0",
+        "description": "Get all values from JSON object"
+    },
+    "JSON Merge": {
+        "prefix": "json::merge",
+        "body": "json::merge(${1:obj1}, ${2:obj2})$0",
+        "description": "Deep merge multiple JSON objects"
+    },
+
+    "Instance GetMethods": {
+        "prefix": "instance::getMethods",
+        "body": "instance::getMethods(${1:@module})$0",
+        "description": "Get all method names from object/module"
+    },
+    "Instance GetClasses": {
+        "prefix": "instance::getClasses",
+        "body": "instance::getClasses(${1:@module})$0",
+        "description": "Get all class names from module"
+    },
+    "Instance GetVars": {
+        "prefix": "instance::getVars",
+        "body": "instance::getVars(${1:@module})$0",
+        "description": "Get all variable/attribute names"
+    },
+    "Instance GetAll": {
+        "prefix": "instance::getAll",
+        "body": "instance::getAll(${1:@module})$0",
+        "description": "Get all attributes categorized"
+    },
+    "Instance Call": {
+        "prefix": "instance::call",
+        "body": "instance::call(${1:@module}, ${2:\"methodName\"}, ${3:args})$0",
+        "description": "Dynamically call method on object"
+    },
+    "Instance Has": {
+        "prefix": "instance::has",
+        "body": "instance::has(${1:@module}, ${2:\"name\"})$0",
+        "description": "Check if object has attribute"
+    },
+    "Instance Type": {
+        "prefix": "instance::type",
+        "body": "instance::type(${1:@module})$0",
+        "description": "Get type name of object"
+    },
+    "IsAvailable": {
+        "prefix": "isavailable",
+        "body": "isavailable(${1:\"name\"})$0",
+        "description": "Check if shared instance exists"
+    },
+    "IsAvailable Check": {
+        "prefix": "isavailable-if",
+        "body": [
+            "if (isavailable(\"${1:name}\")) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Check if shared instance exists with if block"
+    },
+
+    "Match Regex": {
+        "prefix": "match",
+        "body": "match(${1:\"pattern\"}, ${2:string})$0",
+        "description": "Match regex at start of string"
+    },
+    "Search Regex": {
+        "prefix": "search",
+        "body": "search(${1:\"pattern\"}, ${2:string})$0",
+        "description": "Search for regex anywhere in string"
+    },
+    "Findall Regex": {
+        "prefix": "findall",
+        "body": "findall(${1:\"pattern\"}, ${2:string})$0",
+        "description": "Find all regex matches"
+    },
+    "Sub Regex": {
+        "prefix": "sub",
+        "body": "sub(${1:\"pattern\"}, ${2:\"replacement\"}, ${3:string})$0",
+        "description": "Replace all regex matches"
+    },
+
+    "MD5": {
+        "prefix": "md5",
+        "body": "md5(${1:string})$0",
+        "description": "Calculate MD5 hash"
+    },
+    "SHA1": {
+        "prefix": "sha1",
+        "body": "sha1(${1:string})$0",
+        "description": "Calculate SHA1 hash"
+    },
+    "SHA256": {
+        "prefix": "sha256",
+        "body": "sha256(${1:string})$0",
+        "description": "Calculate SHA256 hash"
+    },
+
+    "Exit": {
+        "prefix": "exit",
+        "body": "exit(${1:0});$0",
+        "description": "Exit CSSL execution"
+    },
+    "Input": {
+        "prefix": "input",
+        "body": "input(${1:\"prompt\"})$0",
+        "description": "Read user input from console"
+    },
+    "Env": {
+        "prefix": "env",
+        "body": "env(${1:\"VAR_NAME\"})$0",
+        "description": "Get environment variable"
+    },
+    "Setenv": {
+        "prefix": "setenv",
+        "body": "setenv(${1:\"name\"}, ${2:\"value\"});$0",
+        "description": "Set environment variable"
+    },
+    "Clear": {
+        "prefix": "clear",
+        "body": "clear();$0",
+        "description": "Clear console screen"
+    },
+    "Copy": {
+        "prefix": "copy",
+        "body": "copy(${1:obj})$0",
+        "description": "Create shallow copy of object"
+    },
+    "Deepcopy": {
+        "prefix": "deepcopy",
+        "body": "deepcopy(${1:obj})$0",
+        "description": "Create deep copy of object"
+    },
+    "Pyimport": {
+        "prefix": "pyimport",
+        "body": "@${1:module} = pyimport(\"${2:module_name}\");$0",
+        "description": "Import Python module dynamically"
+    },
+    "Include": {
+        "prefix": "include",
+        "body": "@${1:module} = include(\"${2:path.cssl-mod}\");$0",
+        "description": "Include/import CSSL module"
+    },
+    "Payload": {
+        "prefix": "payload",
+        "body": "payload(\"${1:data.cssl-pl}\");$0",
+        "description": "Load CSSL payload file"
+    },
+
+    "OpenFind": {
+        "prefix": "OpenFind",
+        "body": "OpenFind<${1:int}>(${2:0})$0",
+        "description": "Find open parameter by type or index"
+    },
+    "Datastruct": {
+        "prefix": "datastruct",
+        "body": "datastruct<${1:string}> ${2:data};$0",
+        "description": "Create datastruct container"
+    },
+    "Shuffled": {
+        "prefix": "shuffled",
+        "body": "shuffled<${1:string}> ${2:data};$0",
+        "description": "Create shuffled container for unorganized storage"
+    },
+    "Iterator": {
+        "prefix": "iterator",
+        "body": "iterator<${1:int}> ${2:iter};$0",
+        "description": "Create iterator with programmable tasks"
+    },
+    "Combo": {
+        "prefix": "combo",
+        "body": "combo<${1:dynamic}> ${2:filter};$0",
+        "description": "Create combo filter/search space"
+    },
+    "Share": {
+        "prefix": "share",
+        "body": "share(\"${1:name}\", ${2:obj});$0",
+        "description": "Share Python object with CSSL"
+    },
+    "Delete Shared": {
+        "prefix": "delete",
+        "body": "delete(\"${1:name}\");$0",
+        "description": "Delete shared object"
+    },
+
+    "IsLinux": {
+        "prefix": "isLinux",
+        "body": "isLinux()$0",
+        "description": "Check if running on Linux"
+    },
+    "IsWindows": {
+        "prefix": "isWindows",
+        "body": "isWindows()$0",
+        "description": "Check if running on Windows"
+    },
+    "IsMac": {
+        "prefix": "isMac",
+        "body": "isMac()$0",
+        "description": "Check if running on macOS"
+    },
+
+    "Parameter Get": {
+        "prefix": ["param", "parameter.get"],
+        "body": "${1:type} ${2:name} = parameter.get(${3:0});$0",
+        "description": "Get parameter from Python"
+    },
+    "Parameter Return": {
+        "prefix": ["return", "parameter.return"],
+        "body": "parameter.return(${1:value});$0",
+        "description": "Return value to Python"
+    },
+    "Stack Declaration": {
+        "prefix": ["stack"],
+        "body": "stack<${1:string}> ${2:name};$0",
+        "description": "Create a stack"
+    },
+    "Vector Declaration": {
+        "prefix": ["vector"],
+        "body": "vector<${1:string}> ${2:name};$0",
+        "description": "Create a vector"
+    },
+    "Map Declaration": {
+        "prefix": ["map"],
+        "body": "map<${1:string}, ${2:int}> ${3:name};$0",
+        "description": "Create a map (ordered key-value container)"
+    },
+    "Dictionary Declaration": {
+        "prefix": ["dict", "dictionary"],
+        "body": "dictionary<${1:string}> ${2:name};$0",
+        "description": "Create a dictionary"
+    },
+    "Instance Reference": {
+        "prefix": ["instance<"],
+        "body": "instance<\"${1:name}\"> ${2:var};$0",
+        "description": "Create instance reference"
+    },
+    "Shared Reference": {
+        "prefix": ["$", "shared"],
+        "body": "\\$${1:name}$0",
+        "description": "Shared object reference"
+    },
+    "Module Reference": {
+        "prefix": ["@", "module"],
+        "body": "@${1:ModuleName}$0",
+        "description": "Module reference"
+    },
+    "Code Infusion": {
+        "prefix": ["<<=", "infuse"],
+        "body": [
+            "${1:target} <<== {",
+            "\t$0",
+            "};"
+        ],
+        "description": "Code infusion block"
+    },
+    "Brute Injection": {
+        "prefix": ["<==", "inject"],
+        "body": "${1:target} <== ${2:value};$0",
+        "description": "Brute injection"
+    },
+    "Receive Injection": {
+        "prefix": ["==>", "receive"],
+        "body": "${1:source} ==> ${2:target};$0",
+        "description": "Receive injection"
+    },
+    "Struct Definition": {
+        "prefix": "struct",
+        "body": [
+            "struct ${1:Name} {",
+            "\t${2:field} <== ${3:value};",
+            "\t$0",
+            "}"
+        ],
+        "description": "Create a struct"
+    },
+    "Service Init Block": {
+        "prefix": "service-init",
+        "body": [
+            "service-init {",
+            "\tservice-name <== \"${1:ServiceName}\";",
+            "\tservice-version <== \"${2:1.0.0}\";",
+            "\t$0",
+            "}"
+        ],
+        "description": "Service initialization block"
+    },
+    "Open Define Function": {
+        "prefix": "opendefine",
+        "body": [
+            "open define ${1:FuncName}(open Params) {",
+            "\tindex = OpenFind<int>(0);",
+            "\t$0",
+            "}"
+        ],
+        "description": "Open parameter function"
+    }
+}