@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/sb.json

@@ -0,0 +1,341 @@
+{
+  "language": "sb",
+  "definitions": {
+    "TextWindow": {
+      "signature": "TextWindow",
+      "description": "Provides text-based input and output operations for console-style programs, enabling reading user input from the keyboard and writing formatted text output to the screen.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "WriteLine": {
+          "signature": "TextWindow.WriteLine(data)",
+          "description": "Writes a line of text to the text window followed by a newline character.",
+          "type": "method"
+        },
+        "Write": {
+          "signature": "TextWindow.Write(data)",
+          "description": "Writes text to the text window without appending a newline.",
+          "type": "method"
+        },
+        "Read": {
+          "signature": "TextWindow.Read() -> String",
+          "description": "Reads a full line of text input from the user.",
+          "type": "method"
+        },
+        "ReadNumber": {
+          "signature": "TextWindow.ReadNumber() -> Number",
+          "description": "Reads a numeric value entered by the user.",
+          "type": "method"
+        },
+        "ForegroundColor": {
+          "signature": "TextWindow.ForegroundColor = color",
+          "description": "Gets or sets the foreground color of text displayed in the window.",
+          "type": "method"
+        },
+        "BackgroundColor": {
+          "signature": "TextWindow.BackgroundColor = color",
+          "description": "Gets or sets the background color of the text window.",
+          "type": "method"
+        },
+        "Clear": {
+          "signature": "TextWindow.Clear()",
+          "description": "Clears all text content from the text window.",
+          "type": "method"
+        },
+        "Pause": {
+          "signature": "TextWindow.Pause()",
+          "description": "Pauses execution and waits for the user to press any key.",
+          "type": "method"
+        }
+      }
+    },
+    "GraphicsWindow": {
+      "signature": "GraphicsWindow",
+      "description": "Provides a graphical drawing surface for creating shapes, images, and animations with mouse and keyboard interaction support for building visual Small Basic programs.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "DrawRectangle": {
+          "signature": "GraphicsWindow.DrawRectangle(x, y, width, height)",
+          "description": "Draws a rectangle outline at the specified coordinates with given dimensions.",
+          "type": "method"
+        },
+        "FillRectangle": {
+          "signature": "GraphicsWindow.FillRectangle(x, y, width, height)",
+          "description": "Draws a filled rectangle at the specified coordinates using the current brush color.",
+          "type": "method"
+        },
+        "DrawEllipse": {
+          "signature": "GraphicsWindow.DrawEllipse(x, y, width, height)",
+          "description": "Draws an ellipse outline bounded by the specified rectangle.",
+          "type": "method"
+        },
+        "DrawLine": {
+          "signature": "GraphicsWindow.DrawLine(x1, y1, x2, y2)",
+          "description": "Draws a line between two coordinate points on the graphics surface.",
+          "type": "method"
+        },
+        "DrawText": {
+          "signature": "GraphicsWindow.DrawText(x, y, text)",
+          "description": "Draws text at the specified position using the current font and brush color.",
+          "type": "method"
+        },
+        "Show": {
+          "signature": "GraphicsWindow.Show()",
+          "description": "Displays the graphics window on screen.",
+          "type": "method"
+        },
+        "Width": {
+          "signature": "GraphicsWindow.Width = pixels",
+          "description": "Gets or sets the width of the graphics window in pixels.",
+          "type": "method"
+        },
+        "Height": {
+          "signature": "GraphicsWindow.Height = pixels",
+          "description": "Gets or sets the height of the graphics window in pixels.",
+          "type": "method"
+        },
+        "BrushColor": {
+          "signature": "GraphicsWindow.BrushColor = color",
+          "description": "Gets or sets the brush color used for filling shapes and drawing text.",
+          "type": "method"
+        },
+        "PenColor": {
+          "signature": "GraphicsWindow.PenColor = color",
+          "description": "Gets or sets the pen color used for drawing shape outlines and lines.",
+          "type": "method"
+        },
+        "MouseDown": {
+          "signature": "GraphicsWindow.MouseDown = handler",
+          "description": "Event raised when a mouse button is pressed on the graphics window.",
+          "type": "method"
+        },
+        "KeyDown": {
+          "signature": "GraphicsWindow.KeyDown = handler",
+          "description": "Event raised when a key is pressed while the graphics window has focus.",
+          "type": "method"
+        }
+      }
+    },
+    "Math": {
+      "signature": "Math",
+      "description": "Provides standard mathematical functions and constants including trigonometry, rounding, random number generation, and common numeric operations for calculations.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "Abs": {
+          "signature": "Math.Abs(number) -> Number",
+          "description": "Returns the absolute value of a specified number.",
+          "type": "method"
+        },
+        "Ceiling": {
+          "signature": "Math.Ceiling(number) -> Number",
+          "description": "Returns the smallest integer greater than or equal to the specified number.",
+          "type": "method"
+        },
+        "Floor": {
+          "signature": "Math.Floor(number) -> Number",
+          "description": "Returns the largest integer less than or equal to the specified number.",
+          "type": "method"
+        },
+        "GetRandomNumber": {
+          "signature": "Math.GetRandomNumber(maxNumber) -> Number",
+          "description": "Returns a random integer between 1 and the specified maximum value.",
+          "type": "method"
+        },
+        "Max": {
+          "signature": "Math.Max(number1, number2) -> Number",
+          "description": "Returns the larger of two specified numbers.",
+          "type": "method"
+        },
+        "Min": {
+          "signature": "Math.Min(number1, number2) -> Number",
+          "description": "Returns the smaller of two specified numbers.",
+          "type": "method"
+        },
+        "SquareRoot": {
+          "signature": "Math.SquareRoot(number) -> Number",
+          "description": "Returns the square root of a specified number.",
+          "type": "method"
+        },
+        "Pi": {
+          "signature": "Math.Pi -> Number",
+          "description": "Returns the value of the mathematical constant pi (approximately 3.14159).",
+          "type": "method"
+        },
+        "Sin": {
+          "signature": "Math.Sin(angle) -> Number",
+          "description": "Returns the sine of the specified angle in radians.",
+          "type": "method"
+        },
+        "Cos": {
+          "signature": "Math.Cos(angle) -> Number",
+          "description": "Returns the cosine of the specified angle in radians.",
+          "type": "method"
+        }
+      }
+    },
+    "Clock": {
+      "signature": "Clock",
+      "description": "Provides access to system clock values including current date components, time components, and elapsed milliseconds for timing and date-based program logic.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "Year": {
+          "signature": "Clock.Year -> Number",
+          "description": "Gets the current year.",
+          "type": "method"
+        },
+        "Month": {
+          "signature": "Clock.Month -> Number",
+          "description": "Gets the current month (1-12).",
+          "type": "method"
+        },
+        "Day": {
+          "signature": "Clock.Day -> Number",
+          "description": "Gets the current day of the month.",
+          "type": "method"
+        },
+        "Hour": {
+          "signature": "Clock.Hour -> Number",
+          "description": "Gets the current hour (0-23).",
+          "type": "method"
+        },
+        "Minute": {
+          "signature": "Clock.Minute -> Number",
+          "description": "Gets the current minute (0-59).",
+          "type": "method"
+        },
+        "Second": {
+          "signature": "Clock.Second -> Number",
+          "description": "Gets the current second (0-59).",
+          "type": "method"
+        },
+        "ElapsedMilliseconds": {
+          "signature": "Clock.ElapsedMilliseconds -> Number",
+          "description": "Gets the number of milliseconds elapsed since midnight.",
+          "type": "method"
+        }
+      }
+    },
+    "Timer": {
+      "signature": "Timer",
+      "description": "Provides a repeating timer mechanism that raises tick events at a configurable interval, useful for animations, periodic updates, and time-based game logic.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "Interval": {
+          "signature": "Timer.Interval = milliseconds",
+          "description": "Gets or sets the interval between timer tick events in milliseconds.",
+          "type": "method"
+        },
+        "Tick": {
+          "signature": "Timer.Tick = handler",
+          "description": "Event raised each time the timer interval elapses.",
+          "type": "method"
+        },
+        "Pause": {
+          "signature": "Timer.Pause()",
+          "description": "Pauses the timer to stop tick events from being raised.",
+          "type": "method"
+        },
+        "Resume": {
+          "signature": "Timer.Resume()",
+          "description": "Resumes a previously paused timer.",
+          "type": "method"
+        }
+      }
+    },
+    "Controls": {
+      "signature": "Controls",
+      "description": "Provides user interface controls such as buttons and text boxes that can be placed on the graphics window for building interactive programs with form-like input.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "AddButton": {
+          "signature": "Controls.AddButton(caption, left, top) -> String",
+          "description": "Creates a button with specified caption at the given position and returns its identifier.",
+          "type": "method"
+        },
+        "AddTextBox": {
+          "signature": "Controls.AddTextBox(left, top) -> String",
+          "description": "Creates a text input box at the given position and returns its identifier.",
+          "type": "method"
+        },
+        "AddMultiLineTextBox": {
+          "signature": "Controls.AddMultiLineTextBox(left, top) -> String",
+          "description": "Creates a multi-line text input box at the given position and returns its identifier.",
+          "type": "method"
+        },
+        "GetTextBoxText": {
+          "signature": "Controls.GetTextBoxText(textBoxName) -> String",
+          "description": "Returns the current text content of the specified text box control.",
+          "type": "method"
+        },
+        "SetTextBoxText": {
+          "signature": "Controls.SetTextBoxText(textBoxName, text)",
+          "description": "Sets the text content of the specified text box control.",
+          "type": "method"
+        },
+        "ButtonClicked": {
+          "signature": "Controls.ButtonClicked = handler",
+          "description": "Event raised when any button control is clicked by the user.",
+          "type": "method"
+        },
+        "LastClickedButton": {
+          "signature": "Controls.LastClickedButton -> String",
+          "description": "Returns the name of the button that was most recently clicked.",
+          "type": "method"
+        }
+      }
+    },
+    "Shapes": {
+      "signature": "Shapes",
+      "description": "Provides named shape objects on the graphics window that can be individually moved, rotated, animated, and hidden, enabling sprite-based graphics and simple game development.",
+      "type": "class",
+      "module": "Small Basic Library",
+      "members": {
+        "AddRectangle": {
+          "signature": "Shapes.AddRectangle(width, height) -> String",
+          "description": "Adds a rectangle shape and returns its identifier for later manipulation.",
+          "type": "method"
+        },
+        "AddEllipse": {
+          "signature": "Shapes.AddEllipse(width, height) -> String",
+          "description": "Adds an ellipse shape and returns its identifier for later manipulation.",
+          "type": "method"
+        },
+        "AddTriangle": {
+          "signature": "Shapes.AddTriangle(x1, y1, x2, y2, x3, y3) -> String",
+          "description": "Adds a triangle shape defined by three vertices and returns its identifier.",
+          "type": "method"
+        },
+        "AddImage": {
+          "signature": "Shapes.AddImage(imageName) -> String",
+          "description": "Adds an image as a shape and returns its identifier for later manipulation.",
+          "type": "method"
+        },
+        "Move": {
+          "signature": "Shapes.Move(shapeName, x, y)",
+          "description": "Moves the specified shape to a new position instantly.",
+          "type": "method"
+        },
+        "Animate": {
+          "signature": "Shapes.Animate(shapeName, x, y, duration)",
+          "description": "Smoothly animates the shape to a new position over the specified duration in milliseconds.",
+          "type": "method"
+        },
+        "Rotate": {
+          "signature": "Shapes.Rotate(shapeName, angle)",
+          "description": "Rotates the shape by the specified angle in degrees.",
+          "type": "method"
+        },
+        "Remove": {
+          "signature": "Shapes.Remove(shapeName)",
+          "description": "Removes the specified shape from the graphics window.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}

package/data/defination/scheme.json

@@ -0,0 +1,107 @@
+{
+  "language": "scheme",
+  "definitions": {
+    "define": {
+      "signature": "(define name value) | (define (name params ...) body ...)",
+      "description": "Binds a name to a value or defines a procedure with parameters and body expressions in the current environment, serving as the primary definition form in Scheme programs.",
+      "type": "function",
+      "module": "Core Forms"
+    },
+    "lambda": {
+      "signature": "(lambda (params ...) body ...) -> procedure",
+      "description": "Creates an anonymous procedure (closure) that captures its lexical environment, accepting the specified formal parameters and evaluating the body expressions when called.",
+      "type": "function",
+      "module": "Core Forms"
+    },
+    "let": {
+      "signature": "(let ((var1 expr1) (var2 expr2) ...) body ...) -> value",
+      "description": "Introduces local bindings where all initial value expressions are evaluated in the outer scope before any bindings take effect, then evaluates the body in the extended environment.",
+      "type": "function",
+      "module": "Binding Forms"
+    },
+    "let*": {
+      "signature": "(let* ((var1 expr1) (var2 expr2) ...) body ...) -> value",
+      "description": "Sequential binding form where each variable binding is visible to subsequent binding expressions, allowing later bindings to reference earlier ones in the same let block.",
+      "type": "function",
+      "module": "Binding Forms"
+    },
+    "letrec": {
+      "signature": "(letrec ((var1 expr1) (var2 expr2) ...) body ...) -> value",
+      "description": "Recursive binding form where all variables are in scope for all expressions, enabling mutually recursive procedure definitions within a local binding block.",
+      "type": "function",
+      "module": "Binding Forms"
+    },
+    "cond": {
+      "signature": "(cond (test1 expr1 ...) (test2 expr2 ...) ... (else expr ...)) -> value",
+      "description": "Multi-way conditional expression that evaluates test clauses in order and returns the value of the expression sequence for the first true test, with an optional else clause.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "car": {
+      "signature": "(car pair) -> value",
+      "description": "Returns the first element (head) of a pair or the first element of a non-empty list, raising an error if applied to an empty list or non-pair value.",
+      "type": "function",
+      "module": "Pairs and Lists"
+    },
+    "cdr": {
+      "signature": "(cdr pair) -> value",
+      "description": "Returns the second element (tail) of a pair, or the rest of a list after removing the first element, serving as the fundamental list decomposition operation.",
+      "type": "function",
+      "module": "Pairs and Lists"
+    },
+    "cons": {
+      "signature": "(cons a b) -> pair",
+      "description": "Constructs a new pair from two values; when the second argument is a list, produces a new list with the first argument prepended as the head element.",
+      "type": "function",
+      "module": "Pairs and Lists"
+    },
+    "map": {
+      "signature": "(map procedure list1 list2 ...) -> list",
+      "description": "Applies a procedure element-wise to corresponding elements of one or more lists and returns a new list of the results, preserving the order of elements.",
+      "type": "function",
+      "module": "List Operations"
+    },
+    "fold-left": {
+      "signature": "(fold-left procedure init list) -> value",
+      "description": "Reduces a list from left to right by applying a binary procedure to an accumulator (starting with init) and each element, returning the final accumulated value.",
+      "type": "function",
+      "module": "List Operations"
+    },
+    "call/cc": {
+      "signature": "(call-with-current-continuation procedure) -> value",
+      "description": "Captures the current continuation as a first-class escape procedure and passes it to the given procedure, enabling non-local exits, coroutines, and advanced control flow patterns.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "syntax-rules": {
+      "signature": "(define-syntax name (syntax-rules (literals ...) (pattern template) ...)) -> macro",
+      "description": "Defines a hygienic macro transformer using pattern matching rules, where each pattern is matched against use-site forms and the corresponding template generates the expansion.",
+      "type": "function",
+      "module": "Macros"
+    },
+    "values": {
+      "signature": "(values val1 val2 ...) -> multiple values",
+      "description": "Returns multiple values from a procedure, which can be received by call-with-values or let-values, enabling functions to produce more than one result efficiently.",
+      "type": "function",
+      "module": "Multiple Values"
+    },
+    "apply": {
+      "signature": "(apply procedure arg1 ... args-list) -> value",
+      "description": "Calls a procedure with arguments taken from a list, optionally preceded by individual arguments, effectively spreading the list elements as positional parameters.",
+      "type": "function",
+      "module": "Procedures"
+    },
+    "for-each": {
+      "signature": "(for-each procedure list1 list2 ...) -> void",
+      "description": "Applies a procedure to corresponding elements of one or more lists in order purely for side effects, guaranteed to process elements sequentially unlike map.",
+      "type": "function",
+      "module": "List Operations"
+    },
+    "dynamic-wind": {
+      "signature": "(dynamic-wind before thunk after) -> value",
+      "description": "Executes thunk between before and after procedures, guaranteeing that before runs on entry and after on exit even when continuations transfer control in or out.",
+      "type": "function",
+      "module": "Control Flow"
+    }
+  }
+}

package/data/defination/scss.json

@@ -0,0 +1,95 @@
+{
+  "language": "scss",
+  "definitions": {
+    "@mixin": {
+      "signature": "@mixin name($param1, $param2: default) { ... }",
+      "description": "Defines a reusable block of CSS declarations and logic that can accept parameters with optional defaults, enabling DRY styling patterns across stylesheets with @include invocations.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@include": {
+      "signature": "@include mixin-name($arg1, $arg2) | @include mixin-name { @content }",
+      "description": "Invokes a previously defined mixin by name with arguments, optionally passing a content block that the mixin can inject using @content for flexible wrapper-style mixins.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@extend": {
+      "signature": "@extend selector | @extend selector !optional",
+      "description": "Shares CSS rules between selectors by making the current selector inherit all styles of the extended selector, generating combined selector groups in the compiled CSS output.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@use": {
+      "signature": "@use 'path/module' | @use 'path/module' as namespace | @use 'path/module' with ($var: value)",
+      "description": "Imports and namespaces a Sass module, making its variables, mixins, and functions available under a namespace, replacing @import with better encapsulation and deduplication.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@forward": {
+      "signature": "@forward 'path/module' | @forward 'path/module' as prefix-* | @forward 'path/module' hide $var, mixin-name",
+      "description": "Re-exports members from another module, optionally adding a prefix or hiding specific members, enabling library authors to compose public APIs from multiple source files.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@function": {
+      "signature": "@function name($param1, $param2) { @return value; }",
+      "description": "Defines a custom function that computes and returns a value using @return, callable anywhere a CSS value is expected for dynamic calculations within stylesheets.",
+      "type": "function",
+      "module": "At-Rules"
+    },
+    "@each": {
+      "signature": "@each $var in list | @each $key, $value in map { ... }",
+      "description": "Iterates over items in a list or key-value pairs in a map, generating CSS rules for each iteration, commonly used for producing utility classes or theme variations.",
+      "type": "function",
+      "module": "Control Flow"
+    },
+    "darken": {
+      "signature": "darken($color, $amount) -> Color",
+      "description": "Returns a darker version of the given color by decreasing its lightness by the specified percentage amount, useful for generating hover states and shadow color variations.",
+      "type": "function",
+      "module": "sass:color"
+    },
+    "lighten": {
+      "signature": "lighten($color, $amount) -> Color",
+      "description": "Returns a lighter version of the given color by increasing its lightness by the specified percentage amount, commonly used for creating highlight effects and tint variations.",
+      "type": "function",
+      "module": "sass:color"
+    },
+    "map-get": {
+      "signature": "map-get($map, $key) -> value | null",
+      "description": "Retrieves the value associated with a key in a Sass map data structure, returning null if the key is not found, essential for theme configuration and design token lookups.",
+      "type": "function",
+      "module": "sass:map"
+    },
+    "color.adjust": {
+      "signature": "color.adjust($color, $red: null, $green: null, $blue: null, $hue: null, $saturation: null, $lightness: null, $alpha: null) -> Color",
+      "description": "Creates a new color by adjusting one or more properties of an existing color by fixed amounts, providing precise control over color channel manipulation in the modern module system.",
+      "type": "function",
+      "module": "sass:color"
+    },
+    "map.merge": {
+      "signature": "map.merge($map1, $map2) -> Map",
+      "description": "Combines two maps into a new map where keys from the second map override matching keys in the first, enabling configuration override patterns and theme extension.",
+      "type": "function",
+      "module": "sass:map"
+    },
+    "list.append": {
+      "signature": "list.append($list, $val, $separator: auto) -> List",
+      "description": "Returns a new list with the given value appended to the end, using the specified separator or inheriting the existing list separator for consistent formatting.",
+      "type": "function",
+      "module": "sass:list"
+    },
+    "math.div": {
+      "signature": "math.div($number1, $number2) -> Number",
+      "description": "Performs division of two numbers, replacing the deprecated slash-as-division syntax with an explicit function call to avoid ambiguity with CSS separator slashes.",
+      "type": "function",
+      "module": "sass:math"
+    },
+    "string.unquote": {
+      "signature": "string.unquote($string) -> String",
+      "description": "Removes quotes from a Sass string, returning it as an unquoted string suitable for use as CSS identifiers, property names, and other contexts requiring unquoted values.",
+      "type": "function",
+      "module": "sass:string"
+    }
+  }
+}

package/data/defination/shell.json

@@ -0,0 +1,95 @@
+{
+  "language": "shell",
+  "definitions": {
+    "echo": {
+      "signature": "echo [-neE] [string ...]",
+      "description": "Writes its arguments to standard output separated by spaces followed by a newline. The -n flag suppresses the trailing newline, -e enables backslash escape interpretation.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "test": {
+      "signature": "test expression | [ expression ]",
+      "description": "Evaluates conditional expressions for file attributes, string comparisons, and arithmetic tests, returning exit status 0 for true and 1 for false, used in if statements and loops.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "read": {
+      "signature": "read [-r] [-p prompt] [-t timeout] [-n nchars] [-d delim] [-a array] [name ...]",
+      "description": "Reads a line of input from standard input and splits it into fields assigned to named variables, with -r preventing backslash escape processing and -p displaying a prompt.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "trap": {
+      "signature": "trap [-lp] [action] [signal ...]",
+      "description": "Registers a command to execute when the shell receives specified signals such as EXIT, INT, TERM, or HUP, enabling cleanup handlers and graceful shutdown procedures.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "set": {
+      "signature": "set [-abefhkmnptuvxBCHP] [-o option-name] [-- arg ...]",
+      "description": "Sets or unsets shell options and positional parameters. Common flags include -e (exit on error), -u (treat unset variables as error), -x (print commands before execution).",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "export": {
+      "signature": "export [-fn] [-p] [name[=value] ...]",
+      "description": "Marks variables for automatic export to the environment of subsequently executed child processes, making them available as environment variables in subshells and commands.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "getopts": {
+      "signature": "getopts optstring name [args]",
+      "description": "Parses positional parameters as command-line options according to the optstring specification, setting the named variable to each option found and OPTARG to its argument.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "shift": {
+      "signature": "shift [n]",
+      "description": "Shifts positional parameters to the left by n positions (default 1), discarding the first n parameters and renumbering the remaining ones starting from $1 for argument processing.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "eval": {
+      "signature": "eval [arg ...]",
+      "description": "Concatenates its arguments into a single command string and then executes the result as a shell command, enabling dynamic command construction and variable indirection patterns.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "exec": {
+      "signature": "exec [-cl] [-a name] [command [arguments ...]] [redirection ...]",
+      "description": "Replaces the current shell process with the specified command without creating a new process, or with no command applies redirections to the current shell for file descriptor manipulation.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "source": {
+      "signature": "source filename [arguments] | . filename [arguments]",
+      "description": "Reads and executes commands from the specified file in the current shell environment, making all variable assignments and function definitions persist in the calling shell.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "printf": {
+      "signature": "printf format [arguments ...]",
+      "description": "Formats and outputs text according to a format string with conversion specifiers like %s, %d, %f, providing more precise control over output formatting than echo.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "local": {
+      "signature": "local [option] name[=value] ...",
+      "description": "Declares variables with local scope within a function, preventing modifications from affecting the calling scope, essential for writing reusable shell functions without side effects.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "wait": {
+      "signature": "wait [-fn] [-p varname] [id ...]",
+      "description": "Suspends execution until specified background processes or jobs complete and returns their exit status, or waits for all background children when called without arguments.",
+      "type": "function",
+      "module": "Builtins"
+    },
+    "declare": {
+      "signature": "declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]",
+      "description": "Declares variables with specific attributes such as -i for integer, -a for indexed array, -A for associative array, -r for readonly, and -x for export in bash scripts.",
+      "type": "function",
+      "module": "Builtins"
+    }
+  }
+}