@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/objective-c.json

@@ -0,0 +1,217 @@
+{
+  "language": "objective-c",
+  "definitions": {
+    "NSString": {
+      "signature": "@interface NSString : NSObject",
+      "description": "The fundamental immutable string class in Foundation framework, representing Unicode text with rich manipulation capabilities. NSString objects are created using @\"literal\" syntax or factory methods.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "length": {
+          "signature": "@property (readonly) NSUInteger length",
+          "description": "Returns the number of UTF-16 code units in the string.",
+          "type": "method"
+        },
+        "stringByAppendingString:": {
+          "signature": "- (NSString *)stringByAppendingString:(NSString *)aString",
+          "description": "Returns a new string made by appending the given string to the receiver.",
+          "type": "method"
+        },
+        "substringWithRange:": {
+          "signature": "- (NSString *)substringWithRange:(NSRange)range",
+          "description": "Returns a string containing characters within the specified range.",
+          "type": "method"
+        },
+        "isEqualToString:": {
+          "signature": "- (BOOL)isEqualToString:(NSString *)aString",
+          "description": "Compares the receiver with the given string for Unicode equality.",
+          "type": "method"
+        },
+        "stringWithFormat:": {
+          "signature": "+ (instancetype)stringWithFormat:(NSString *)format, ...",
+          "description": "Creates a new string using a format string and arguments, similar to sprintf.",
+          "type": "method"
+        },
+        "componentsSeparatedByString:": {
+          "signature": "- (NSArray<NSString *> *)componentsSeparatedByString:(NSString *)separator",
+          "description": "Splits the string into substrings at each occurrence of the separator.",
+          "type": "method"
+        }
+      }
+    },
+    "NSArray": {
+      "signature": "@interface NSArray<ObjectType> : NSObject",
+      "description": "An ordered immutable collection of objects in Foundation framework, created using @[] literal syntax. Elements are accessed by zero-based index and must be Objective-C objects, not primitive types.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "count": {
+          "signature": "@property (readonly) NSUInteger count",
+          "description": "Returns the number of objects in the array.",
+          "type": "method"
+        },
+        "objectAtIndex:": {
+          "signature": "- (ObjectType)objectAtIndex:(NSUInteger)index",
+          "description": "Returns the object at the specified index, raising NSRangeException if out of bounds.",
+          "type": "method"
+        },
+        "containsObject:": {
+          "signature": "- (BOOL)containsObject:(ObjectType)anObject",
+          "description": "Returns YES if the array contains an object equal to the given object.",
+          "type": "method"
+        },
+        "enumerateObjectsUsingBlock:": {
+          "signature": "- (void)enumerateObjectsUsingBlock:(void (^)(ObjectType obj, NSUInteger idx, BOOL *stop))block",
+          "description": "Iterates over all objects in the array, executing the block for each element.",
+          "type": "method"
+        },
+        "filteredArrayUsingPredicate:": {
+          "signature": "- (NSArray<ObjectType> *)filteredArrayUsingPredicate:(NSPredicate *)predicate",
+          "description": "Returns a new array containing only elements that match the given predicate.",
+          "type": "method"
+        }
+      }
+    },
+    "NSDictionary": {
+      "signature": "@interface NSDictionary<KeyType, ObjectType> : NSObject",
+      "description": "An immutable collection of key-value pairs in Foundation framework, created using @{} literal syntax. Keys must conform to NSCopying protocol and are typically NSString objects.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "count": {
+          "signature": "@property (readonly) NSUInteger count",
+          "description": "Returns the number of key-value pairs in the dictionary.",
+          "type": "method"
+        },
+        "objectForKey:": {
+          "signature": "- (ObjectType)objectForKey:(KeyType)aKey",
+          "description": "Returns the value associated with the given key, or nil if not found.",
+          "type": "method"
+        },
+        "allKeys": {
+          "signature": "@property (readonly, copy) NSArray<KeyType> *allKeys",
+          "description": "Returns an array containing all keys in the dictionary.",
+          "type": "method"
+        },
+        "allValues": {
+          "signature": "@property (readonly, copy) NSArray<ObjectType> *allValues",
+          "description": "Returns an array containing all values in the dictionary.",
+          "type": "method"
+        },
+        "enumerateKeysAndObjectsUsingBlock:": {
+          "signature": "- (void)enumerateKeysAndObjectsUsingBlock:(void (^)(KeyType key, ObjectType obj, BOOL *stop))block",
+          "description": "Iterates over all key-value pairs, executing the block for each entry.",
+          "type": "method"
+        }
+      }
+    },
+    "NSNumber": {
+      "signature": "@interface NSNumber : NSValue",
+      "description": "An immutable object wrapper for C numeric types including int, float, double, and BOOL. Created using @() literal syntax or factory methods like numberWithInt: for boxing primitives.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "integerValue": {
+          "signature": "@property (readonly) NSInteger integerValue",
+          "description": "Returns the value as an NSInteger (platform-native signed integer).",
+          "type": "method"
+        },
+        "floatValue": {
+          "signature": "@property (readonly) float floatValue",
+          "description": "Returns the value as a float.",
+          "type": "method"
+        },
+        "doubleValue": {
+          "signature": "@property (readonly) double doubleValue",
+          "description": "Returns the value as a double.",
+          "type": "method"
+        },
+        "boolValue": {
+          "signature": "@property (readonly) BOOL boolValue",
+          "description": "Returns the value as a BOOL (YES or NO).",
+          "type": "method"
+        }
+      }
+    },
+    "NSMutableArray": {
+      "signature": "@interface NSMutableArray<ObjectType> : NSArray",
+      "description": "A mutable ordered collection that extends NSArray with methods for adding, removing, and replacing elements. Created using [NSMutableArray array] or [[NSMutableArray alloc] init] factory patterns.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "addObject:": {
+          "signature": "- (void)addObject:(ObjectType)anObject",
+          "description": "Appends an object to the end of the mutable array.",
+          "type": "method"
+        },
+        "removeObjectAtIndex:": {
+          "signature": "- (void)removeObjectAtIndex:(NSUInteger)index",
+          "description": "Removes the object at the specified index from the array.",
+          "type": "method"
+        },
+        "insertObject:atIndex:": {
+          "signature": "- (void)insertObject:(ObjectType)anObject atIndex:(NSUInteger)index",
+          "description": "Inserts an object at the specified index, shifting subsequent elements.",
+          "type": "method"
+        },
+        "removeAllObjects": {
+          "signature": "- (void)removeAllObjects",
+          "description": "Removes all objects from the mutable array, leaving it empty.",
+          "type": "method"
+        },
+        "sortUsingComparator:": {
+          "signature": "- (void)sortUsingComparator:(NSComparator)cmptr",
+          "description": "Sorts the array in place using the given comparison block.",
+          "type": "method"
+        }
+      }
+    },
+    "NSMutableDictionary": {
+      "signature": "@interface NSMutableDictionary<KeyType, ObjectType> : NSDictionary",
+      "description": "A mutable collection of key-value pairs extending NSDictionary with methods for adding, updating, and removing entries. Commonly used for building dynamic configuration and state containers.",
+      "type": "class",
+      "module": "Foundation",
+      "members": {
+        "setObject:forKey:": {
+          "signature": "- (void)setObject:(ObjectType)anObject forKey:(KeyType<NSCopying>)aKey",
+          "description": "Adds or replaces the value for the given key in the dictionary.",
+          "type": "method"
+        },
+        "removeObjectForKey:": {
+          "signature": "- (void)removeObjectForKey:(KeyType)aKey",
+          "description": "Removes the key-value pair for the specified key from the dictionary.",
+          "type": "method"
+        },
+        "removeAllObjects": {
+          "signature": "- (void)removeAllObjects",
+          "description": "Removes all key-value pairs from the mutable dictionary.",
+          "type": "method"
+        }
+      }
+    },
+    "NSLog": {
+      "signature": "void NSLog(NSString *format, ...)",
+      "description": "Logs a formatted message to the Apple System Log facility and standard error, prepending a timestamp and process information. Accepts printf-style format specifiers and %@ for objects.",
+      "type": "function",
+      "module": "Foundation"
+    },
+    "dispatch_async": {
+      "signature": "void dispatch_async(dispatch_queue_t queue, dispatch_block_t block)",
+      "description": "Submits a block for asynchronous execution on the specified Grand Central Dispatch queue and returns immediately. Essential for offloading work to background threads and updating UI on the main queue.",
+      "type": "function",
+      "module": "Dispatch"
+    },
+    "dispatch_queue_create": {
+      "signature": "dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)",
+      "description": "Creates a new dispatch queue with the specified label and attributes. Pass DISPATCH_QUEUE_SERIAL for serial execution or DISPATCH_QUEUE_CONCURRENT for concurrent task processing.",
+      "type": "function",
+      "module": "Dispatch"
+    },
+    "@selector": {
+      "signature": "@selector(methodName:)",
+      "description": "Compiler directive that returns a SEL type representing the specified method selector, used for target-action patterns, performSelector calls, and dynamic method invocation in Objective-C runtime.",
+      "type": "function",
+      "module": "Runtime"
+    }
+  }
+}

package/data/defination/pascal.json

@@ -0,0 +1,175 @@
+{
+  "language": "pascal",
+  "definitions": {
+    "WriteLn": {
+      "signature": "WriteLn(args: ...)",
+      "description": "Writes one or more values to standard output followed by a newline character. Accepts mixed types including strings, integers, reals, and booleans with optional field width formatting specifiers.",
+      "type": "function",
+      "module": "System"
+    },
+    "ReadLn": {
+      "signature": "ReadLn(var args: ...)",
+      "description": "Reads a line of input from standard input, assigning values to the specified variables and consuming the newline character. Used for interactive console input in Pascal programs.",
+      "type": "function",
+      "module": "System"
+    },
+    "Write": {
+      "signature": "Write(args: ...)",
+      "description": "Writes one or more values to standard output without appending a newline, allowing multiple write calls to produce a single output line before the cursor remains on the same line.",
+      "type": "function",
+      "module": "System"
+    },
+    "Integer": {
+      "signature": "Integer",
+      "description": "The standard signed integer type in Pascal, typically 16-bit in Turbo Pascal or 32-bit in Free Pascal and Delphi. Supports arithmetic operations, comparisons, and ordinal functions.",
+      "type": "class",
+      "module": "System"
+    },
+    "String": {
+      "signature": "String[maxLength]",
+      "description": "The character string type in Pascal, storing a sequence of characters with a length byte prefix. Default maximum length is 255 characters. Supports concatenation, comparison, and index access.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "Length": {
+          "signature": "Length(s: String) -> Integer",
+          "description": "Returns the number of characters currently stored in the string.",
+          "type": "method"
+        },
+        "Copy": {
+          "signature": "Copy(s: String, index: Integer, count: Integer) -> String",
+          "description": "Returns a substring from s starting at index for count characters.",
+          "type": "method"
+        },
+        "Pos": {
+          "signature": "Pos(substr: String, s: String) -> Integer",
+          "description": "Returns the position of the first occurrence of substr in s, or 0 if not found.",
+          "type": "method"
+        },
+        "Delete": {
+          "signature": "Delete(var s: String, index: Integer, count: Integer)",
+          "description": "Removes count characters from string s starting at the specified index.",
+          "type": "method"
+        },
+        "Insert": {
+          "signature": "Insert(source: String, var s: String, index: Integer)",
+          "description": "Inserts the source string into s at the specified index position.",
+          "type": "method"
+        }
+      }
+    },
+    "Real": {
+      "signature": "Real",
+      "description": "The floating-point numeric type in Pascal for storing decimal numbers. Typically 48-bit in Turbo Pascal or mapped to Double (64-bit) in Free Pascal and Delphi for IEEE 754 compliance.",
+      "type": "class",
+      "module": "System"
+    },
+    "Boolean": {
+      "signature": "Boolean",
+      "description": "The logical type in Pascal with exactly two values: True and False. Used in conditional expressions, control flow statements, and as function return types for predicate operations.",
+      "type": "class",
+      "module": "System"
+    },
+    "Array": {
+      "signature": "Array[indexType] of elementType",
+      "description": "A fixed-size collection of elements of the same type, indexed by an ordinal type range. Arrays in Pascal are declared with explicit bounds and support multidimensional and packed variants.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "Low": {
+          "signature": "Low(a: Array) -> indexType",
+          "description": "Returns the lowest valid index value for the array.",
+          "type": "method"
+        },
+        "High": {
+          "signature": "High(a: Array) -> indexType",
+          "description": "Returns the highest valid index value for the array.",
+          "type": "method"
+        },
+        "Length": {
+          "signature": "Length(a: Array) -> Integer",
+          "description": "Returns the number of elements in the array (or dynamic array).",
+          "type": "method"
+        },
+        "SetLength": {
+          "signature": "SetLength(var a: DynArray, newLength: Integer)",
+          "description": "Resizes a dynamic array to the specified length, preserving existing elements.",
+          "type": "method"
+        }
+      }
+    },
+    "Record": {
+      "signature": "Record field1: Type1; field2: Type2; end",
+      "description": "A composite data type that groups related fields of different types under a single name. Records support variant parts, can be nested, and are used for structured data modeling in Pascal.",
+      "type": "class",
+      "module": "System"
+    },
+    "TStringList": {
+      "signature": "TStringList = class(TStrings)",
+      "description": "A powerful string collection class in the Classes unit providing sorted and unsorted string lists with name-value pair support, file I/O, and delimiter-separated text parsing capabilities.",
+      "type": "class",
+      "module": "Classes",
+      "members": {
+        "Add": {
+          "signature": "function Add(const S: string): Integer",
+          "description": "Adds a string to the list and returns its zero-based index.",
+          "type": "method"
+        },
+        "Delete": {
+          "signature": "procedure Delete(Index: Integer)",
+          "description": "Removes the string at the specified zero-based index from the list.",
+          "type": "method"
+        },
+        "IndexOf": {
+          "signature": "function IndexOf(const S: string): Integer",
+          "description": "Returns the zero-based index of the first matching string, or -1 if not found.",
+          "type": "method"
+        },
+        "Sort": {
+          "signature": "procedure Sort",
+          "description": "Sorts the string list in ascending alphabetical order.",
+          "type": "method"
+        },
+        "LoadFromFile": {
+          "signature": "procedure LoadFromFile(const FileName: string)",
+          "description": "Loads the contents of a text file into the string list, one line per entry.",
+          "type": "method"
+        },
+        "SaveToFile": {
+          "signature": "procedure SaveToFile(const FileName: string)",
+          "description": "Saves the contents of the string list to a text file, one line per entry.",
+          "type": "method"
+        },
+        "Count": {
+          "signature": "@property Count: Integer",
+          "description": "Returns the number of strings currently in the list.",
+          "type": "method"
+        }
+      }
+    },
+    "Ord": {
+      "signature": "Ord(x: ordinal) -> Integer",
+      "description": "Returns the ordinal value (integer position) of an ordinal-type expression, including characters, booleans, and enumeration values. For Char arguments, returns the ASCII code value.",
+      "type": "function",
+      "module": "System"
+    },
+    "Chr": {
+      "signature": "Chr(x: Byte) -> Char",
+      "description": "Returns the character corresponding to the specified ASCII code value. The inverse of the Ord function, converting an integer byte value back to its character representation.",
+      "type": "function",
+      "module": "System"
+    },
+    "Inc": {
+      "signature": "Inc(var x: ordinal [, n: Integer])",
+      "description": "Increments an ordinal variable by 1 or by the optional amount n. More efficient than x := x + 1 as it generates optimized machine code for the increment operation.",
+      "type": "function",
+      "module": "System"
+    },
+    "Dec": {
+      "signature": "Dec(var x: ordinal [, n: Integer])",
+      "description": "Decrements an ordinal variable by 1 or by the optional amount n. More efficient than x := x - 1 as it generates optimized machine code for the decrement operation.",
+      "type": "function",
+      "module": "System"
+    }
+  }
+}

package/data/defination/pascaligo.json

@@ -0,0 +1,183 @@
+{
+  "language": "pascaligo",
+  "definitions": {
+    "int": {
+      "signature": "int",
+      "description": "The signed integer type in PascaLIGO representing whole numbers of arbitrary precision on the Tezos blockchain. Supports standard arithmetic operations and comparison for smart contract logic.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "nat": {
+      "signature": "nat",
+      "description": "The natural number type in PascaLIGO representing non-negative integers. Used for counters, token amounts, and sizes where negative values are semantically invalid in smart contracts.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "string": {
+      "signature": "string",
+      "description": "The string type in PascaLIGO representing immutable sequences of characters. Supports concatenation with the caret operator and provides size and slice operations for text manipulation.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "String.concat": {
+          "signature": "String.concat(a: string, b: string) -> string",
+          "description": "Concatenates two strings and returns the combined result.",
+          "type": "method"
+        },
+        "String.length": {
+          "signature": "String.length(s: string) -> nat",
+          "description": "Returns the length of the string as a natural number.",
+          "type": "method"
+        },
+        "String.sub": {
+          "signature": "String.sub(offset: nat, length: nat, s: string) -> string",
+          "description": "Returns a substring starting at offset with the given length.",
+          "type": "method"
+        }
+      }
+    },
+    "tez": {
+      "signature": "tez",
+      "description": "The native currency type in PascaLIGO representing Tezos tokens (XTZ). Values are expressed in mutez (millionths of tez) internally and support arithmetic for financial smart contract operations.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "address": {
+      "signature": "address",
+      "description": "The Tezos account address type in PascaLIGO, representing implicit accounts (tz1/tz2/tz3) or originated contracts (KT1). Used for identifying transaction participants and contract targets.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "map": {
+      "signature": "map(key_type, value_type)",
+      "description": "An immutable key-value mapping type in PascaLIGO that stores associations between keys and values. Maps are suitable for small datasets and support lookup, update, and iteration operations.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "Map.find_opt": {
+          "signature": "Map.find_opt(key: k, m: map(k, v)) -> option(v)",
+          "description": "Looks up a key in the map and returns Some(value) if found, or None otherwise.",
+          "type": "method"
+        },
+        "Map.update": {
+          "signature": "Map.update(key: k, value: option(v), m: map(k, v)) -> map(k, v)",
+          "description": "Returns a new map with the key updated to the given value, or removed if None.",
+          "type": "method"
+        },
+        "Map.add": {
+          "signature": "Map.add(key: k, value: v, m: map(k, v)) -> map(k, v)",
+          "description": "Returns a new map with the key-value pair added or replaced.",
+          "type": "method"
+        },
+        "Map.remove": {
+          "signature": "Map.remove(key: k, m: map(k, v)) -> map(k, v)",
+          "description": "Returns a new map with the specified key removed.",
+          "type": "method"
+        },
+        "Map.size": {
+          "signature": "Map.size(m: map(k, v)) -> nat",
+          "description": "Returns the number of key-value pairs in the map.",
+          "type": "method"
+        }
+      }
+    },
+    "big_map": {
+      "signature": "big_map(key_type, value_type)",
+      "description": "A lazily deserialized key-value mapping optimized for large datasets on the Tezos blockchain. Unlike map, big_map entries are loaded on demand, reducing gas costs for contracts with many entries.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "Big_map.find_opt": {
+          "signature": "Big_map.find_opt(key: k, m: big_map(k, v)) -> option(v)",
+          "description": "Looks up a key in the big_map and returns Some(value) if found, or None.",
+          "type": "method"
+        },
+        "Big_map.update": {
+          "signature": "Big_map.update(key: k, value: option(v), m: big_map(k, v)) -> big_map(k, v)",
+          "description": "Returns a new big_map with the key updated or removed based on the option value.",
+          "type": "method"
+        }
+      }
+    },
+    "list": {
+      "signature": "list(element_type)",
+      "description": "An immutable singly-linked list type in PascaLIGO supporting prepend with cons operator, pattern matching for head/tail decomposition, and functional operations like map, fold, and iter.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "List.map": {
+          "signature": "List.map(f: (a -> b), l: list(a)) -> list(b)",
+          "description": "Applies a function to each element and returns a new list of results.",
+          "type": "method"
+        },
+        "List.fold": {
+          "signature": "List.fold(f: ((acc, a) -> acc), l: list(a), init: acc) -> acc",
+          "description": "Reduces the list to a single value by applying a function with an accumulator.",
+          "type": "method"
+        },
+        "List.iter": {
+          "signature": "List.iter(f: (a -> unit), l: list(a)) -> unit",
+          "description": "Applies a side-effecting function to each element of the list.",
+          "type": "method"
+        },
+        "List.size": {
+          "signature": "List.size(l: list(a)) -> nat",
+          "description": "Returns the number of elements in the list.",
+          "type": "method"
+        }
+      }
+    },
+    "set": {
+      "signature": "set(element_type)",
+      "description": "An immutable collection of unique elements in PascaLIGO. Sets are ordered and support membership testing, addition, removal, and iteration for managing distinct value collections in contracts.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "Set.mem": {
+          "signature": "Set.mem(element: a, s: set(a)) -> bool",
+          "description": "Returns true if the element is a member of the set.",
+          "type": "method"
+        },
+        "Set.add": {
+          "signature": "Set.add(element: a, s: set(a)) -> set(a)",
+          "description": "Returns a new set with the element added.",
+          "type": "method"
+        },
+        "Set.remove": {
+          "signature": "Set.remove(element: a, s: set(a)) -> set(a)",
+          "description": "Returns a new set with the element removed.",
+          "type": "method"
+        },
+        "Set.size": {
+          "signature": "Set.size(s: set(a)) -> nat",
+          "description": "Returns the number of elements in the set.",
+          "type": "method"
+        }
+      }
+    },
+    "option": {
+      "signature": "option(value_type)",
+      "description": "An algebraic type representing an optional value that is either Some(value) or None. Used extensively in PascaLIGO for safe handling of values that may or may not exist, such as map lookups.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "Tezos.sender": {
+      "signature": "Tezos.sender -> address",
+      "description": "Returns the address of the account or contract that directly called the current entry point. Essential for access control and authorization logic in Tezos smart contracts.",
+      "type": "function",
+      "module": "Tezos"
+    },
+    "Tezos.amount": {
+      "signature": "Tezos.amount -> tez",
+      "description": "Returns the amount of tez sent with the current transaction. Used for payable entry point validation and ensuring correct payment amounts in financial smart contracts.",
+      "type": "function",
+      "module": "Tezos"
+    },
+    "failwith": {
+      "signature": "failwith(error_message: string) -> never",
+      "description": "Terminates the current contract execution and reverts all state changes with the given error message. The primary mechanism for enforcing preconditions and access control in PascaLIGO.",
+      "type": "function",
+      "module": "builtin"
+    }
+  }
+}