@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/restructuredtext.json

@@ -0,0 +1,77 @@
+{
+  "language": "restructuredtext",
+  "definitions": {
+    "code-block": {
+      "signature": ".. code-block:: language\n   :linenos:\n   :emphasize-lines: 1,3\n\n   code content",
+      "description": "Displays a block of source code with syntax highlighting for the specified language, supporting line numbers, emphasized lines, caption text, and dedent options for documentation.",
+      "type": "function",
+      "module": "Directives"
+    },
+    "image": {
+      "signature": ".. image:: path/to/image.png\n   :alt: Alternative text\n   :width: 400px\n   :height: 300px\n   :align: center",
+      "description": "Inserts an image into the document with optional alternative text, dimensions, alignment, and scaling parameters for accessible and responsive documentation rendering.",
+      "type": "function",
+      "module": "Directives"
+    },
+    "figure": {
+      "signature": ".. figure:: path/to/image.png\n   :alt: Alt text\n   :figwidth: 80%\n   :align: center\n\n   Caption text",
+      "description": "Inserts an image wrapped in a figure element with an optional caption and legend, providing semantic grouping for illustrations with descriptive text below them.",
+      "type": "function",
+      "module": "Directives"
+    },
+    "note": {
+      "signature": ".. note::\n\n   Note content paragraph",
+      "description": "Creates a visually distinct admonition block to highlight important supplementary information that readers should pay attention to but is not critical or dangerous.",
+      "type": "function",
+      "module": "Admonitions"
+    },
+    "warning": {
+      "signature": ".. warning::\n\n   Warning content paragraph",
+      "description": "Creates a prominent admonition block to alert readers about potentially dangerous operations, breaking changes, or situations that could cause data loss or errors.",
+      "type": "function",
+      "module": "Admonitions"
+    },
+    "toctree": {
+      "signature": ".. toctree::\n   :maxdepth: 2\n   :caption: Title\n   :numbered:\n   :hidden:\n\n   document1\n   document2",
+      "description": "Generates a table of contents tree linking to sub-documents, controlling navigation hierarchy depth, numbering, visibility, and captions for structured documentation sites.",
+      "type": "function",
+      "module": "Directives"
+    },
+    "ref": {
+      "signature": ":ref:`label-name` or :ref:`Display Text <label-name>`",
+      "description": "Creates a cross-reference link to a labeled location anywhere in the documentation set, automatically resolving the section title or using custom display text.",
+      "type": "function",
+      "module": "Roles"
+    },
+    "doc": {
+      "signature": ":doc:`document-path` or :doc:`Display Text <document-path>`",
+      "description": "Creates a hyperlink to another document in the documentation tree using the document name without file extension, with optional custom display text override.",
+      "type": "function",
+      "module": "Roles"
+    },
+    "automodule": {
+      "signature": ".. automodule:: module_name\n   :members:\n   :undoc-members:\n   :show-inheritance:",
+      "description": "Sphinx autodoc directive that automatically extracts and formats documentation from Python module docstrings, class definitions, and function signatures into structured output.",
+      "type": "function",
+      "module": "Sphinx Extensions"
+    },
+    "literalinclude": {
+      "signature": ".. literalinclude:: path/to/file.py\n   :language: python\n   :lines: 1-10\n   :emphasize-lines: 3,5",
+      "description": "Includes the contents of an external file as a literal code block with syntax highlighting, supporting line range selection and emphasis for documentation examples.",
+      "type": "function",
+      "module": "Directives"
+    },
+    "glossary": {
+      "signature": ".. glossary::\n   :sorted:\n\n   term\n      Definition of the term.",
+      "description": "Defines a glossary of terms that can be referenced elsewhere using the :term: role, automatically generating definition list formatting with optional alphabetical sorting.",
+      "type": "function",
+      "module": "Directives"
+    },
+    "deprecated": {
+      "signature": ".. deprecated:: version\n   Description of deprecation and migration path.",
+      "description": "Marks a feature or API as deprecated since the specified version, providing a visible notice with migration guidance for users of the documented software.",
+      "type": "function",
+      "module": "Directives"
+    }
+  }
+}

package/data/definition/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/definition/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/definition/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"
+    }
+  }
+}