@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/less.json

@@ -0,0 +1,65 @@
+{
+  "language": "less",
+  "definitions": {
+    "color": {
+      "signature": "color(string) -> color",
+      "description": "Parses a color string (hex, rgb, rgba, hsl, hsla, or named color keyword) and returns a color value that can be used in further color manipulation functions. This is the base function for constructing color values programmatically in Less stylesheets.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "darken": {
+      "signature": "darken(color, amount[, method]) -> color",
+      "description": "Decreases the lightness of the given color by the specified percentage amount in the HSL color space. The optional method parameter can be set to 'relative' for relative percentage changes instead of absolute. Useful for generating darker variants of a base color for hover states or borders.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "lighten": {
+      "signature": "lighten(color, amount[, method]) -> color",
+      "description": "Increases the lightness of the given color by the specified percentage amount in the HSL color space. Commonly used for creating lighter shades for backgrounds, disabled states, and accent variations from a primary theme color.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "mix": {
+      "signature": "mix(color1, color2[, weight]) -> color",
+      "description": "Blends two colors together proportionally based on the weight parameter (defaulting to 50%). A weight of 25% mixes 25% of color1 with 75% of color2. Opacity is also factored into the weighting calculation for semi-transparent colors.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "fade": {
+      "signature": "fade(color, amount) -> color",
+      "description": "Sets the absolute opacity of a color to the specified percentage amount (0% to 100%). Unlike fadein/fadeout which adjust opacity relatively, fade sets it to an exact value, making it predictable for creating semi-transparent overlay colors.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "spin": {
+      "signature": "spin(color, angle) -> color",
+      "description": "Rotates the hue of a color by the given angle in degrees on the color wheel (0 to 360). Positive values rotate clockwise, negative counter-clockwise. Useful for generating complementary and analogous color schemes from a single base color.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "percentage": {
+      "signature": "percentage(number) -> percentage",
+      "description": "Converts a unitless number to a percentage value by multiplying by 100. For example, percentage(0.5) returns 50%. Useful when computing relative dimensions or widths from ratios stored in variables.",
+      "type": "function",
+      "module": "Less Math Functions"
+    },
+    "unit": {
+      "signature": "unit(dimension[, unit]) -> number|dimension",
+      "description": "Changes or removes the unit of a dimension value. With one argument, strips the unit and returns a unitless number. With two arguments, replaces the unit with the specified one. Commonly used for unit conversions and arithmetic between incompatible unit types.",
+      "type": "function",
+      "module": "Less Math Functions"
+    },
+    ".mixin": {
+      "signature": ".mixin-name(@param1: default, @param2: default) { ... }",
+      "description": "Defines a reusable set of CSS declarations (a mixin) that can accept parameters with optional default values. Mixins are invoked by their selector name and can be included in any ruleset. They support pattern matching, guards (when conditions), and the ... rest argument syntax for variadic parameters.",
+      "type": "keyword",
+      "module": "Less Mixins"
+    },
+    "@variable": {
+      "signature": "@variable-name: value;",
+      "description": "Declares a Less variable that stores a value for reuse throughout the stylesheet. Variables can hold colors, dimensions, strings, or any CSS value and are evaluated lazily — meaning the last definition in scope wins. They enable centralized theming, consistent spacing scales, and easy global style changes.",
+      "type": "keyword",
+      "module": "Less Variables"
+    }
+  }
+}

package/data/defination/lexon.json

@@ -0,0 +1,65 @@
+{
+  "language": "lexon",
+  "definitions": {
+    "CLAUSE": {
+      "signature": "CLAUSE: <clause_name>.",
+      "description": "Defines a named clause within a Lexon legal contract that encapsulates a specific contractual provision or rule. Clauses are the primary structural units of Lexon contracts, containing statements that specify obligations, permissions, and conditions that govern the behavior of the contracting parties.",
+      "type": "keyword",
+      "module": "Lexon Contract Structure"
+    },
+    "TERMS": {
+      "signature": "TERMS: <terms_description>.",
+      "description": "Declares the overarching terms section of a Lexon contract, establishing the scope and context of the contractual agreement. The terms block contains all clauses, covenants, and definitions that constitute the complete legal arrangement between parties.",
+      "type": "keyword",
+      "module": "Lexon Contract Structure"
+    },
+    "LEX": {
+      "signature": "LEX: <contract_name>.",
+      "description": "The top-level declaration that names and initiates a Lexon smart legal contract. Every Lexon program begins with a LEX statement that identifies the contract, followed by the terms and clauses that define the agreement's provisions and executable logic.",
+      "type": "keyword",
+      "module": "Lexon Contract Structure"
+    },
+    "COVENANT": {
+      "signature": "COVENANT: <covenant_description>.",
+      "description": "Specifies a binding promise or agreement within the contract that one or more parties commit to fulfilling. Covenants in Lexon represent strong contractual commitments that are intended to be enforceable and may trigger obligations or consequences if breached.",
+      "type": "keyword",
+      "module": "Lexon Contract Terms"
+    },
+    "CONDITION": {
+      "signature": "IF <condition> THEN <action>.",
+      "description": "Defines a conditional clause that executes an action only when a specified condition evaluates to true. Conditions enable dynamic contract behavior by allowing different outcomes based on events, dates, states, or party actions during contract execution.",
+      "type": "keyword",
+      "module": "Lexon Contract Logic"
+    },
+    "OBLIGATION": {
+      "signature": "<party> SHALL <action>.",
+      "description": "Declares a mandatory duty that a named party must perform under the contract. Obligations are enforceable requirements — failure to fulfill an obligation may constitute a breach of contract and trigger remedial clauses or penalty provisions defined elsewhere.",
+      "type": "keyword",
+      "module": "Lexon Contract Terms"
+    },
+    "PERMISSION": {
+      "signature": "<party> MAY <action>.",
+      "description": "Grants a named party the right (but not the obligation) to perform a specified action under the contract. Permissions define optional capabilities that contracting parties can exercise at their discretion within the bounds of the agreement.",
+      "type": "keyword",
+      "module": "Lexon Contract Terms"
+    },
+    "PAY": {
+      "signature": "<payer> SHALL PAY <amount> TO <payee>.",
+      "description": "Specifies a payment obligation where one party must transfer a monetary amount to another party. In smart-contract compilation, PAY statements translate to token transfer operations on the blockchain, automating the financial settlement described in the legal text.",
+      "type": "keyword",
+      "module": "Lexon Contract Actions"
+    },
+    "CERTIFY": {
+      "signature": "<certifier> SHALL CERTIFY <statement>.",
+      "description": "Requires a designated party to attest or verify the truth of a statement or the occurrence of an event. Certification actions serve as oracles or attestation points in the contract, enabling off-chain facts to influence on-chain contract execution.",
+      "type": "keyword",
+      "module": "Lexon Contract Actions"
+    },
+    "TERMINATE": {
+      "signature": "TERMINATE.",
+      "description": "Ends the execution of the contract or a specific clause, releasing parties from further obligations defined within the terminated scope. Termination may be conditional (triggered by breach or expiration) or voluntary when explicitly invoked by an authorized party.",
+      "type": "keyword",
+      "module": "Lexon Contract Actions"
+    }
+  }
+}

package/data/defination/liquid.json

@@ -0,0 +1,176 @@
+{
+  "language": "liquid",
+  "definitions": {
+    "assign": {
+      "signature": "{% assign variable = value %}",
+      "description": "Creates a new named variable and assigns it a value within a Liquid template, persisting for the remainder of the template rendering context.",
+      "type": "function",
+      "module": "tags"
+    },
+    "capture": {
+      "signature": "{% capture variable %}...{% endcapture %}",
+      "description": "Captures the rendered content between the opening and closing tags into a string variable, allowing complex string building from template fragments.",
+      "type": "function",
+      "module": "tags"
+    },
+    "for": {
+      "signature": "{% for item in collection %}...{% endfor %}",
+      "description": "Iterates over an array or range, rendering the enclosed block for each element. Supports limit, offset, reversed parameters and exposes forloop object with index, first, last properties.",
+      "type": "function",
+      "module": "tags",
+      "members": {
+        "forloop.index": {
+          "signature": "forloop.index -> Integer",
+          "description": "Returns the 1-based index of the current iteration within the for loop.",
+          "type": "method"
+        },
+        "forloop.index0": {
+          "signature": "forloop.index0 -> Integer",
+          "description": "Returns the 0-based index of the current iteration within the for loop.",
+          "type": "method"
+        },
+        "forloop.first": {
+          "signature": "forloop.first -> Boolean",
+          "description": "Returns true if the current iteration is the first one in the loop.",
+          "type": "method"
+        },
+        "forloop.last": {
+          "signature": "forloop.last -> Boolean",
+          "description": "Returns true if the current iteration is the last one in the loop.",
+          "type": "method"
+        },
+        "forloop.length": {
+          "signature": "forloop.length -> Integer",
+          "description": "Returns the total number of iterations in the for loop.",
+          "type": "method"
+        }
+      }
+    },
+    "if": {
+      "signature": "{% if condition %}...{% endif %}",
+      "description": "Conditionally renders enclosed content when the given expression evaluates to a truthy value. Supports elsif and else branches for multiple condition paths.",
+      "type": "function",
+      "module": "tags"
+    },
+    "unless": {
+      "signature": "{% unless condition %}...{% endunless %}",
+      "description": "Renders enclosed content only when the given condition evaluates to false or nil, acting as the inverse of the if tag for cleaner negation logic.",
+      "type": "function",
+      "module": "tags"
+    },
+    "case": {
+      "signature": "{% case variable %}{% when value %}...{% endcase %}",
+      "description": "Creates a switch-style conditional that checks a variable against multiple when values and renders the matching block, with optional else for default output.",
+      "type": "function",
+      "module": "tags"
+    },
+    "include": {
+      "signature": "{% include 'snippet' %}",
+      "description": "Inserts the rendered content of another template file into the current template. Supports passing variables with the with keyword for parameterized partial rendering. Deprecated in favor of render.",
+      "type": "function",
+      "module": "tags"
+    },
+    "render": {
+      "signature": "{% render 'snippet', var: value %}",
+      "description": "Renders a partial template in an isolated scope, preventing it from accessing or modifying the parent template variables. Preferred over include for better encapsulation and performance.",
+      "type": "function",
+      "module": "tags"
+    },
+    "comment": {
+      "signature": "{% comment %}...{% endcomment %}",
+      "description": "Prevents any content between the opening and closing tags from being rendered in the final output, useful for adding developer notes or temporarily disabling template sections.",
+      "type": "function",
+      "module": "tags"
+    },
+    "raw": {
+      "signature": "{% raw %}...{% endraw %}",
+      "description": "Outputs the enclosed content without processing any Liquid tags or objects, allowing display of Liquid code examples or curly-brace syntax in template output.",
+      "type": "function",
+      "module": "tags"
+    },
+    "append": {
+      "signature": "{{ value | append: 'string' }} -> String",
+      "description": "String filter that concatenates the given string to the end of the input value, commonly used for building URLs, file paths, or composite display strings.",
+      "type": "function",
+      "module": "filters"
+    },
+    "prepend": {
+      "signature": "{{ value | prepend: 'string' }} -> String",
+      "description": "String filter that adds the specified string to the beginning of the input value, useful for prefixing paths, protocols, or labels to existing strings.",
+      "type": "function",
+      "module": "filters"
+    },
+    "downcase": {
+      "signature": "{{ value | downcase }} -> String",
+      "description": "Converts all characters in the input string to lowercase, useful for normalizing user input, generating URL slugs, or case-insensitive display formatting.",
+      "type": "function",
+      "module": "filters"
+    },
+    "upcase": {
+      "signature": "{{ value | upcase }} -> String",
+      "description": "Converts all characters in the input string to uppercase, commonly used for headings, labels, or emphasis in template output rendering.",
+      "type": "function",
+      "module": "filters"
+    },
+    "split": {
+      "signature": "{{ value | split: 'delimiter' }} -> Array",
+      "description": "Divides a string into an array of substrings based on the specified delimiter, enabling iteration over comma-separated lists, path segments, or other structured text.",
+      "type": "function",
+      "module": "filters"
+    },
+    "join": {
+      "signature": "{{ array | join: 'glue' }} -> String",
+      "description": "Combines all elements of an array into a single string, inserting the specified glue string between each element for formatted list output.",
+      "type": "function",
+      "module": "filters"
+    },
+    "strip_html": {
+      "signature": "{{ value | strip_html }} -> String",
+      "description": "Removes all HTML tags from the input string, producing plain text output suitable for meta descriptions, excerpts, or non-HTML contexts.",
+      "type": "function",
+      "module": "filters"
+    },
+    "date": {
+      "signature": "{{ value | date: 'format' }} -> String",
+      "description": "Converts a timestamp or date string into a formatted date string using strftime-compatible format directives such as %Y for year, %m for month, and %d for day.",
+      "type": "function",
+      "module": "filters"
+    },
+    "where": {
+      "signature": "{{ array | where: 'property', 'value' }} -> Array",
+      "description": "Filters an array of objects, returning only those whose specified property matches the given value. Essential for querying collections by attributes in Shopify and Jekyll templates.",
+      "type": "function",
+      "module": "filters"
+    },
+    "map": {
+      "signature": "{{ array | map: 'property' }} -> Array",
+      "description": "Extracts the values of a specific property from each object in an array, producing a new array of those values for iteration or display.",
+      "type": "function",
+      "module": "filters"
+    },
+    "sort": {
+      "signature": "{{ array | sort: 'property' }} -> Array",
+      "description": "Returns a sorted copy of the input array. When a property name is specified, sorts objects by that property value in ascending order.",
+      "type": "function",
+      "module": "filters"
+    },
+    "size": {
+      "signature": "{{ value | size }} -> Integer",
+      "description": "Returns the number of characters in a string or the number of elements in an array, commonly used in conditional checks for empty collections or length limits.",
+      "type": "function",
+      "module": "filters"
+    },
+    "default": {
+      "signature": "{{ value | default: 'fallback' }} -> Any",
+      "description": "Returns the input value if it is present and not empty; otherwise returns the specified fallback value, providing safe defaults for potentially nil or blank variables.",
+      "type": "function",
+      "module": "filters"
+    },
+    "replace": {
+      "signature": "{{ value | replace: 'search', 'replacement' }} -> String",
+      "description": "Replaces all occurrences of the search string in the input with the replacement string, useful for text transformations, sanitization, and URL slug generation.",
+      "type": "function",
+      "module": "filters"
+    }
+  }
+}

package/data/defination/m3.json

@@ -0,0 +1,220 @@
+{
+  "language": "m3",
+  "definitions": {
+    "TEXT": {
+      "signature": "TEXT",
+      "description": "The built-in immutable string type in Modula-3, representing a sequence of characters with reference semantics. TEXT values are garbage-collected and support concatenation with the ampersand operator.",
+      "type": "class",
+      "module": "Text",
+      "members": {
+        "Length": {
+          "signature": "Text.Length(t: TEXT) -> CARDINAL",
+          "description": "Returns the number of characters in the given text value.",
+          "type": "method"
+        },
+        "GetChar": {
+          "signature": "Text.GetChar(t: TEXT, i: CARDINAL) -> CHAR",
+          "description": "Returns the character at position i in the text, with zero-based indexing.",
+          "type": "method"
+        },
+        "Sub": {
+          "signature": "Text.Sub(t: TEXT, start: CARDINAL, length: CARDINAL) -> TEXT",
+          "description": "Returns a substring of t starting at position start with the given length.",
+          "type": "method"
+        },
+        "Equal": {
+          "signature": "Text.Equal(t: TEXT, u: TEXT) -> BOOLEAN",
+          "description": "Returns TRUE if the two text values contain identical character sequences.",
+          "type": "method"
+        },
+        "Cat": {
+          "signature": "Text.Cat(t: TEXT, u: TEXT) -> TEXT",
+          "description": "Concatenates two text values and returns the combined result.",
+          "type": "method"
+        }
+      }
+    },
+    "INTEGER": {
+      "signature": "INTEGER",
+      "description": "The built-in signed integer type in Modula-3, representing whole numbers within the platform-dependent range. Supports standard arithmetic, comparison, and bitwise operations defined by the language.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "REAL": {
+      "signature": "REAL",
+      "description": "The standard single-precision floating-point type in Modula-3, conforming to IEEE 754 representation. Used for numeric computations requiring fractional values with moderate precision.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "LONGREAL": {
+      "signature": "LONGREAL",
+      "description": "The double-precision floating-point type in Modula-3, providing higher precision than REAL for scientific and mathematical computations requiring greater accuracy in decimal representation.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "BOOLEAN": {
+      "signature": "BOOLEAN = {FALSE, TRUE}",
+      "description": "The built-in enumeration type with exactly two values, FALSE and TRUE, used for logical operations, conditionals, and control flow in Modula-3 programs.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "CHAR": {
+      "signature": "CHAR",
+      "description": "The built-in character type representing a single 8-bit character in the ISO Latin-1 character set. CHAR values are ordinal and support ORD and VAL operations for conversion.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "ARRAY": {
+      "signature": "ARRAY [index_type] OF element_type",
+      "description": "A fixed-size or open array type in Modula-3 that stores elements of a uniform type indexed by an ordinal type. Open arrays use ARRAY OF T syntax and are passed by reference.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "NUMBER": {
+          "signature": "NUMBER(a: ARRAY) -> CARDINAL",
+          "description": "Returns the number of elements in the array.",
+          "type": "method"
+        },
+        "FIRST": {
+          "signature": "FIRST(a: ARRAY) -> index_type",
+          "description": "Returns the first valid index of the array.",
+          "type": "method"
+        },
+        "LAST": {
+          "signature": "LAST(a: ARRAY) -> index_type",
+          "description": "Returns the last valid index of the array.",
+          "type": "method"
+        }
+      }
+    },
+    "RECORD": {
+      "signature": "RECORD field1: Type1; field2: Type2; END",
+      "description": "A composite value type in Modula-3 that groups named fields of potentially different types into a single structured data unit, similar to structs in C or records in Pascal.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "NEW": {
+      "signature": "NEW(T, ...) -> REF T",
+      "description": "Allocates heap memory for a reference type and returns a traced reference to the newly created object. Accepts optional field initializers for record and object types in Modula-3.",
+      "type": "function",
+      "module": "builtin"
+    },
+    "THREAD": {
+      "signature": "THREAD",
+      "description": "The standard Modula-3 interface for concurrent programming, providing thread creation via Fork, synchronization with Mutex and Condition variables, and cooperative scheduling primitives.",
+      "type": "interface",
+      "module": "Thread",
+      "members": {
+        "Fork": {
+          "signature": "Thread.Fork(cl: Thread.Closure) -> Thread.T",
+          "description": "Creates and starts a new thread executing the given closure's apply method.",
+          "type": "method"
+        },
+        "Join": {
+          "signature": "Thread.Join(t: Thread.T) -> REFANY",
+          "description": "Blocks the calling thread until thread t completes and returns its result.",
+          "type": "method"
+        },
+        "Wait": {
+          "signature": "Thread.Wait(m: MUTEX, c: Thread.Condition)",
+          "description": "Atomically releases the mutex and suspends the thread until the condition is signaled.",
+          "type": "method"
+        },
+        "Signal": {
+          "signature": "Thread.Signal(c: Thread.Condition)",
+          "description": "Wakes one thread waiting on the given condition variable.",
+          "type": "method"
+        },
+        "Broadcast": {
+          "signature": "Thread.Broadcast(c: Thread.Condition)",
+          "description": "Wakes all threads waiting on the given condition variable.",
+          "type": "method"
+        }
+      }
+    },
+    "Fmt": {
+      "signature": "Fmt",
+      "description": "The standard formatting interface in Modula-3 providing functions to convert integers, reals, booleans, and characters to their TEXT representations for output and string construction.",
+      "type": "interface",
+      "module": "Fmt",
+      "members": {
+        "Int": {
+          "signature": "Fmt.Int(n: INTEGER, base: [2..16]) -> TEXT",
+          "description": "Converts an integer to its text representation in the specified base.",
+          "type": "method"
+        },
+        "Real": {
+          "signature": "Fmt.Real(x: REAL, style: Fmt.Style, prec: CARDINAL) -> TEXT",
+          "description": "Converts a real number to text with the given formatting style and precision.",
+          "type": "method"
+        },
+        "Bool": {
+          "signature": "Fmt.Bool(b: BOOLEAN) -> TEXT",
+          "description": "Returns the text TRUE or FALSE for the given boolean value.",
+          "type": "method"
+        },
+        "Char": {
+          "signature": "Fmt.Char(c: CHAR) -> TEXT",
+          "description": "Converts a single character to a one-character text value.",
+          "type": "method"
+        }
+      }
+    },
+    "Wr": {
+      "signature": "Wr",
+      "description": "The standard writer interface in Modula-3 providing buffered output streams for writing text to files, standard output, and other destinations with flush and close operations.",
+      "type": "interface",
+      "module": "Wr",
+      "members": {
+        "PutText": {
+          "signature": "Wr.PutText(wr: Wr.T, t: TEXT)",
+          "description": "Writes the given text string to the output writer stream.",
+          "type": "method"
+        },
+        "PutChar": {
+          "signature": "Wr.PutChar(wr: Wr.T, c: CHAR)",
+          "description": "Writes a single character to the output writer stream.",
+          "type": "method"
+        },
+        "Flush": {
+          "signature": "Wr.Flush(wr: Wr.T)",
+          "description": "Flushes any buffered output to the underlying destination.",
+          "type": "method"
+        },
+        "Close": {
+          "signature": "Wr.Close(wr: Wr.T)",
+          "description": "Flushes remaining output and closes the writer, releasing associated resources.",
+          "type": "method"
+        }
+      }
+    },
+    "Rd": {
+      "signature": "Rd",
+      "description": "The standard reader interface in Modula-3 providing buffered input streams for reading characters and lines from files, standard input, and other sources with EOF detection.",
+      "type": "interface",
+      "module": "Rd",
+      "members": {
+        "GetChar": {
+          "signature": "Rd.GetChar(rd: Rd.T) -> CHAR",
+          "description": "Reads and returns the next character from the input reader stream.",
+          "type": "method"
+        },
+        "GetLine": {
+          "signature": "Rd.GetLine(rd: Rd.T) -> TEXT",
+          "description": "Reads and returns text up to the next newline character from the input stream.",
+          "type": "method"
+        },
+        "EOF": {
+          "signature": "Rd.EOF(rd: Rd.T) -> BOOLEAN",
+          "description": "Returns TRUE if the reader has reached the end of the input stream.",
+          "type": "method"
+        },
+        "Close": {
+          "signature": "Rd.Close(rd: Rd.T)",
+          "description": "Closes the reader and releases associated resources.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}

package/data/defination/mdx.json

@@ -0,0 +1,78 @@
+{
+  "language": "mdx",
+  "definitions": {
+    "export": {
+      "signature": "export const name = value",
+      "description": "Exports a JavaScript value, component, or function from an MDX file, making it available for import by other modules. Supports named exports and default exports for layout components.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "import": {
+      "signature": "import { Component } from 'module'",
+      "description": "Imports JavaScript modules, React components, or other MDX files into the current document, enabling use of external components and utilities within the markdown content.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "export default": {
+      "signature": "export default (props) => <Layout>{props.children}</Layout>",
+      "description": "Defines a default export wrapper component that controls the layout of the entire MDX document, receiving the rendered content as children for custom page structure.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "JSX Component": {
+      "signature": "<Component prop={value}>children</Component>",
+      "description": "Embeds a JSX or React component directly within markdown content, passing props and children. Components are resolved from imports or the MDXProvider component mapping context.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "MDXProvider": {
+      "signature": "<MDXProvider components={mapping}>children</MDXProvider>",
+      "description": "A React context provider that supplies custom component mappings to MDX content, allowing replacement of standard HTML elements like h1, p, a, code with custom React components.",
+      "type": "class",
+      "module": "@mdx-js/react",
+      "members": {
+        "components": {
+          "signature": "components: Record<string, React.ComponentType>",
+          "description": "An object mapping HTML tag names to React components used for rendering.",
+          "type": "method"
+        }
+      }
+    },
+    "frontmatter": {
+      "signature": "---\ntitle: string\ndate: string\n---",
+      "description": "YAML metadata block at the top of an MDX file enclosed by triple dashes, defining document properties like title, date, author, and custom fields accessible via props or plugins.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "useMDXComponents": {
+      "signature": "useMDXComponents() -> Record<string, React.ComponentType>",
+      "description": "A React hook that returns the current MDX component mapping from the nearest MDXProvider context, enabling custom components to access and extend the component resolution chain.",
+      "type": "function",
+      "module": "@mdx-js/react"
+    },
+    "remarkPlugins": {
+      "signature": "remarkPlugins: Plugin[]",
+      "description": "Configuration option specifying remark plugins that transform the markdown AST before compilation, enabling features like GitHub-flavored markdown, math expressions, and custom syntax extensions.",
+      "type": "interface",
+      "module": "@mdx-js/mdx"
+    },
+    "rehypePlugins": {
+      "signature": "rehypePlugins: Plugin[]",
+      "description": "Configuration option specifying rehype plugins that transform the HTML or JSX AST after markdown processing, enabling features like syntax highlighting, heading anchors, and HTML sanitization.",
+      "type": "interface",
+      "module": "@mdx-js/mdx"
+    },
+    "compile": {
+      "signature": "compile(source: string, options?: CompileOptions) -> Promise<VFile>",
+      "description": "Compiles an MDX string into JavaScript code that exports a React component. Accepts remark and rehype plugins, JSX runtime configuration, and output format options.",
+      "type": "function",
+      "module": "@mdx-js/mdx"
+    },
+    "evaluate": {
+      "signature": "evaluate(source: string, options: EvaluateOptions) -> Promise<MDXModule>",
+      "description": "Compiles and evaluates an MDX string at runtime, returning the default export component and any named exports. Requires a JSX runtime to be provided in options.",
+      "type": "function",
+      "module": "@mdx-js/mdx"
+    }
+  }
+}