@enjoys/context-engine 1.0.0 → 1.0.1

package/data/hover/html.json

@@ -0,0 +1,250 @@
+{
+  "language": "html",
+  "hovers": {
+    "div": {
+      "contents": [
+        { "value": "```html\n<div>...</div>\n```\nThe `<div>` element is the generic container for flow content. It has no effect on the content or layout until styled with CSS. Use semantic elements when possible." }
+      ]
+    },
+    "span": {
+      "contents": [
+        { "value": "```html\n<span>...</span>\n```\nThe `<span>` element is a generic inline container for phrasing content. It does not inherently represent anything. Use it to group elements for styling or when no other semantic element is appropriate." }
+      ]
+    },
+    "p": {
+      "contents": [
+        { "value": "```html\n<p>...</p>\n```\nThe `<p>` element represents a paragraph of text. Browsers automatically add margin before and after the element. It cannot contain block-level elements." }
+      ]
+    },
+    "a": {
+      "contents": [
+        { "value": "```html\n<a href=\"url\" target=\"_blank\" rel=\"noopener\">...</a>\n```\nThe `<a>` (anchor) element creates a hyperlink to web pages, files, email addresses, locations, or anything a URL can address. The `href` attribute specifies the destination." }
+      ]
+    },
+    "img": {
+      "contents": [
+        { "value": "```html\n<img src=\"url\" alt=\"description\" width=\"\" height=\"\" loading=\"lazy\" />\n```\nThe `<img>` element embeds an image. The `src` attribute is required. Always include `alt` for accessibility. Use `loading=\"lazy\"` for off-screen images. Specify `width` and `height` to prevent layout shifts." }
+      ]
+    },
+    "ul": {
+      "contents": [
+        { "value": "```html\n<ul>\n  <li>Item</li>\n</ul>\n```\nThe `<ul>` element represents an unordered list of items, typically rendered as a bulleted list. It may only contain `<li>`, `<script>`, or `<template>` elements." }
+      ]
+    },
+    "ol": {
+      "contents": [
+        { "value": "```html\n<ol start=\"1\" type=\"1\" reversed>\n  <li>Item</li>\n</ol>\n```\nThe `<ol>` element represents an ordered list of items, typically rendered as a numbered list. Supports `start`, `type`, and `reversed` attributes." }
+      ]
+    },
+    "li": {
+      "contents": [
+        { "value": "```html\n<li value=\"3\">Item</li>\n```\nThe `<li>` element represents an item in a list. It must be contained in `<ul>`, `<ol>`, or `<menu>`. In an `<ol>`, the `value` attribute sets the ordinal number." }
+      ]
+    },
+    "table": {
+      "contents": [
+        { "value": "```html\n<table>\n  <thead><tr><th>Header</th></tr></thead>\n  <tbody><tr><td>Data</td></tr></tbody>\n</table>\n```\nThe `<table>` element represents tabular data. Use `<thead>`, `<tbody>`, and `<tfoot>` for semantic structuring. Avoid using tables for layout." }
+      ]
+    },
+    "tr": {
+      "contents": [
+        { "value": "```html\n<tr>\n  <td>Cell</td>\n</tr>\n```\nThe `<tr>` element defines a row of cells in a table. It can contain `<td>` (data cells) and `<th>` (header cells)." }
+      ]
+    },
+    "td": {
+      "contents": [
+        { "value": "```html\n<td colspan=\"2\" rowspan=\"1\">Cell data</td>\n```\nThe `<td>` element defines a standard data cell in a table. Use `colspan` and `rowspan` to span multiple columns or rows." }
+      ]
+    },
+    "th": {
+      "contents": [
+        { "value": "```html\n<th scope=\"col\" colspan=\"2\">Header</th>\n```\nThe `<th>` element defines a header cell in a table. Use the `scope` attribute (`col`, `row`, `colgroup`, `rowgroup`) to associate headers with cells for accessibility." }
+      ]
+    },
+    "form": {
+      "contents": [
+        { "value": "```html\n<form action=\"/submit\" method=\"post\" enctype=\"multipart/form-data\">\n  ...\n</form>\n```\nThe `<form>` element represents a document section containing interactive controls for submitting information. Key attributes: `action`, `method`, `enctype`, `novalidate`." }
+      ]
+    },
+    "input": {
+      "contents": [
+        { "value": "```html\n<input type=\"text\" name=\"field\" value=\"\" placeholder=\"hint\" required />\n```\nThe `<input>` element creates interactive controls for web forms. The `type` attribute determines behavior: text, password, email, number, checkbox, radio, file, date, range, color, hidden, submit, etc." }
+      ]
+    },
+    "button": {
+      "contents": [
+        { "value": "```html\n<button type=\"submit|button|reset\" disabled>Label</button>\n```\nThe `<button>` element represents a clickable button. Types: `submit` (default in forms), `button` (no default behavior), `reset` (resets form). Can contain HTML, unlike `<input type=\"button\">`." }
+      ]
+    },
+    "select": {
+      "contents": [
+        { "value": "```html\n<select name=\"choice\" multiple size=\"4\">\n  <option value=\"a\">A</option>\n</select>\n```\nThe `<select>` element represents a control providing a menu of options. Use `multiple` for multi-select, `size` to show more options. Group with `<optgroup>`." }
+      ]
+    },
+    "option": {
+      "contents": [
+        { "value": "```html\n<option value=\"val\" selected disabled>Label</option>\n```\nThe `<option>` element defines an item in a `<select>`, `<optgroup>`, or `<datalist>`. The `value` attribute is sent on form submission; displayed text is the element content." }
+      ]
+    },
+    "textarea": {
+      "contents": [
+        { "value": "```html\n<textarea name=\"msg\" rows=\"4\" cols=\"50\" maxlength=\"500\" placeholder=\"Type here...\"></textarea>\n```\nThe `<textarea>` element represents a multi-line plain-text editing control. Control size with `rows`/`cols` or CSS. Supports `maxlength`, `minlength`, `placeholder`, `wrap`." }
+      ]
+    },
+    "label": {
+      "contents": [
+        { "value": "```html\n<label for=\"inputId\">Label text</label>\n```\nThe `<label>` element represents a caption for a form control. Use the `for` attribute matching the `id` of the associated control, or wrap the control inside the label." }
+      ]
+    },
+    "h1": {
+      "contents": [
+        { "value": "```html\n<h1>Page Title</h1>\n```\nThe `<h1>` element represents a top-level heading. There should be only one `<h1>` per page. Headings help define document outline and are critical for SEO and accessibility." }
+      ]
+    },
+    "h2": {
+      "contents": [
+        { "value": "```html\n<h2>Section Title</h2>\n```\nThe `<h2>` element represents a second-level heading. Use it for major sections beneath the page title." }
+      ]
+    },
+    "h3": {
+      "contents": [
+        { "value": "```html\n<h3>Sub-section Title</h3>\n```\nThe `<h3>` element represents a third-level heading. Use it for sub-sections within an `<h2>` section." }
+      ]
+    },
+    "h4": {
+      "contents": [
+        { "value": "```html\n<h4>Heading</h4>\n```\nThe `<h4>` element represents a fourth-level heading. Provides further sub-sectioning under `<h3>`." }
+      ]
+    },
+    "h5": {
+      "contents": [
+        { "value": "```html\n<h5>Heading</h5>\n```\nThe `<h5>` element represents a fifth-level heading." }
+      ]
+    },
+    "h6": {
+      "contents": [
+        { "value": "```html\n<h6>Heading</h6>\n```\nThe `<h6>` element represents the lowest level of heading. Rarely needed — consider restructuring content if deeply nested." }
+      ]
+    },
+    "header": {
+      "contents": [
+        { "value": "```html\n<header>\n  <h1>Title</h1>\n  <nav>...</nav>\n</header>\n```\nThe `<header>` element represents introductory content or a set of navigational links. It typically contains headings, logos, search forms, or navigation." }
+      ]
+    },
+    "footer": {
+      "contents": [
+        { "value": "```html\n<footer>\n  <p>&copy; 2025</p>\n</footer>\n```\nThe `<footer>` element represents a footer for its nearest sectioning content or sectioning root. Typically contains authorship, copyright, related links." }
+      ]
+    },
+    "nav": {
+      "contents": [
+        { "value": "```html\n<nav aria-label=\"Main\">\n  <ul><li><a href=\"/\">Home</a></li></ul>\n</nav>\n```\nThe `<nav>` element represents a section of a page with navigation links. Not all link groups need `<nav>` — use it for major navigation blocks. Add `aria-label` when using multiple nav elements." }
+      ]
+    },
+    "main": {
+      "contents": [
+        { "value": "```html\n<main>\n  <!-- primary content -->\n</main>\n```\nThe `<main>` element represents the dominant content of the `<body>`. There must be only one visible `<main>` per page. Content should be unique and not repeated across pages (skip nav, sidebars, etc.)." }
+      ]
+    },
+    "section": {
+      "contents": [
+        { "value": "```html\n<section aria-labelledby=\"title\">\n  <h2 id=\"title\">Section Title</h2>\n</section>\n```\nThe `<section>` element represents a standalone section of content that doesn't have a more specific semantic element. Each section should typically have a heading." }
+      ]
+    },
+    "article": {
+      "contents": [
+        { "value": "```html\n<article>\n  <h2>Title</h2>\n  <p>Content...</p>\n</article>\n```\nThe `<article>` element represents a self-contained composition intended for independent distribution or reuse — e.g., a blog post, news article, forum post, or widget." }
+      ]
+    },
+    "aside": {
+      "contents": [
+        { "value": "```html\n<aside>\n  <h3>Related</h3>\n  <p>Sidebar content</p>\n</aside>\n```\nThe `<aside>` element represents content tangentially related to the content around it — sidebars, call-out boxes, related links, or pull quotes." }
+      ]
+    },
+    "figure": {
+      "contents": [
+        { "value": "```html\n<figure>\n  <img src=\"photo.jpg\" alt=\"desc\" />\n  <figcaption>Caption</figcaption>\n</figure>\n```\nThe `<figure>` element represents self-contained content, frequently with a caption (`<figcaption>`). Can contain images, illustrations, diagrams, code snippets, etc." }
+      ]
+    },
+    "figcaption": {
+      "contents": [
+        { "value": "```html\n<figcaption>Image caption</figcaption>\n```\nThe `<figcaption>` element represents a caption or legend for a `<figure>` element. It should be the first or last child of its parent `<figure>`." }
+      ]
+    },
+    "details": {
+      "contents": [
+        { "value": "```html\n<details open>\n  <summary>Click to toggle</summary>\n  <p>Hidden content revealed on toggle.</p>\n</details>\n```\nThe `<details>` element creates a disclosure widget where information is visible only when toggled open. The `open` attribute controls initial state. Always include a `<summary>` child." }
+      ]
+    },
+    "summary": {
+      "contents": [
+        { "value": "```html\n<summary>Toggle heading</summary>\n```\nThe `<summary>` element specifies a visible heading for a `<details>` disclosure widget. It must be the first child of `<details>`. Clicking it toggles the widget open/closed." }
+      ]
+    },
+    "dialog": {
+      "contents": [
+        { "value": "```html\n<dialog id=\"dlg\">\n  <p>Content</p>\n  <button onclick=\"this.closest('dialog').close()\">Close</button>\n</dialog>\n```\nThe `<dialog>` element represents a dialog box or interactive component (modal or non-modal). Use `.showModal()` for modal dialogs, `.show()` for non-modal. Includes built-in focus trapping and backdrop." }
+      ]
+    },
+    "template": {
+      "contents": [
+        { "value": "```html\n<template id=\"card-tmpl\">\n  <div class=\"card\">...</div>\n</template>\n```\nThe `<template>` element holds HTML content that is not rendered when the page loads but can be cloned and inserted into the DOM via JavaScript. Useful for reusable components." }
+      ]
+    },
+    "slot": {
+      "contents": [
+        { "value": "```html\n<slot name=\"header\">Default content</slot>\n```\nThe `<slot>` element is a placeholder inside a Web Component's shadow DOM. It allows consumers to insert their own markup. Named slots target specific elements with `slot=\"name\"` attribute." }
+      ]
+    },
+    "video": {
+      "contents": [
+        { "value": "```html\n<video src=\"movie.mp4\" controls width=\"640\" height=\"360\" poster=\"thumb.jpg\">\n  <track kind=\"subtitles\" src=\"subs.vtt\" srclang=\"en\" />\n</video>\n```\nThe `<video>` element embeds a media player for video playback. Key attributes: `controls`, `autoplay`, `muted`, `loop`, `poster`, `preload`. Use `<source>` for multiple formats and `<track>` for subtitles." }
+      ]
+    },
+    "audio": {
+      "contents": [
+        { "value": "```html\n<audio controls>\n  <source src=\"audio.mp3\" type=\"audio/mpeg\" />\n</audio>\n```\nThe `<audio>` element embeds sound content. Supports `controls`, `autoplay`, `muted`, `loop`, `preload`. Use multiple `<source>` elements for format fallbacks." }
+      ]
+    },
+    "canvas": {
+      "contents": [
+        { "value": "```html\n<canvas id=\"myCanvas\" width=\"400\" height=\"300\"></canvas>\n```\nThe `<canvas>` element is a container for graphics drawn via JavaScript (Canvas 2D API or WebGL). Set dimensions via attributes (not CSS) to avoid scaling. Falls back to inner content when unsupported." }
+      ]
+    },
+    "iframe": {
+      "contents": [
+        { "value": "```html\n<iframe src=\"page.html\" width=\"600\" height=\"400\" title=\"Embedded\" sandbox loading=\"lazy\"></iframe>\n```\nThe `<iframe>` element embeds another HTML page. Use `sandbox` attribute to restrict capabilities. Use `loading=\"lazy\"` for performance. Always include `title` for accessibility." }
+      ]
+    },
+    "link": {
+      "contents": [
+        { "value": "```html\n<link rel=\"stylesheet\" href=\"styles.css\" />\n<link rel=\"icon\" href=\"favicon.ico\" />\n<link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n```\nThe `<link>` element specifies relationships between the document and external resources. Most commonly used for stylesheets, icons, preloading, and DNS prefetching." }
+      ]
+    },
+    "meta": {
+      "contents": [
+        { "value": "```html\n<meta charset=\"UTF-8\" />\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n<meta name=\"description\" content=\"Page description\" />\n```\nThe `<meta>` element provides metadata about the HTML document. Used for character encoding, viewport settings, descriptions, Open Graph tags, and HTTP equiv directives." }
+      ]
+    },
+    "script": {
+      "contents": [
+        { "value": "```html\n<script src=\"app.js\" defer></script>\n<script type=\"module\" src=\"mod.js\"></script>\n```\nThe `<script>` element embeds or references executable JavaScript. Use `defer` to delay execution until DOM is parsed. Use `async` for independent scripts. `type=\"module\"` enables ES module syntax." }
+      ]
+    },
+    "picture": {
+      "contents": [
+        { "value": "```html\n<picture>\n  <source srcset=\"img.avif\" type=\"image/avif\" />\n  <source srcset=\"img.webp\" type=\"image/webp\" />\n  <img src=\"img.jpg\" alt=\"description\" />\n</picture>\n```\nThe `<picture>` element contains `<source>` elements and one `<img>` fallback for responsive and art-directed images. The browser picks the best matching source based on media queries and supported formats." }
+      ]
+    },
+    "source": {
+      "contents": [
+        { "value": "```html\n<source src=\"video.webm\" type=\"video/webm\" />\n<source srcset=\"image.webp\" type=\"image/webp\" media=\"(min-width: 800px)\" />\n```\nThe `<source>` element specifies multiple media resources for `<picture>`, `<audio>`, or `<video>`. The browser selects the first supported source." }
+      ]
+    },
+    "svg": {
+      "contents": [
+        { "value": "```html\n<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 100 100\" width=\"100\" height=\"100\">\n  <circle cx=\"50\" cy=\"50\" r=\"40\" fill=\"blue\" />\n</svg>\n```\nThe `<svg>` element is a container for SVG (Scalable Vector Graphics). SVG is resolution-independent and supports shapes, paths, text, gradients, filters, and animations." }
+      ]
+    }
+  }
+}

package/data/hover/java.json

@@ -0,0 +1,395 @@
+{
+  "language": "java",
+  "hovers": {
+    "System.out.println": {
+      "contents": [
+        { "value": "```java\npublic void println(String x)\n```\nPrints a String and then terminates the line. This method behaves as if it invokes `print(String)` and then `println()`.\n\nBelongs to `java.io.PrintStream`. Commonly accessed via `System.out`." }
+      ]
+    },
+    "System.out.print": {
+      "contents": [
+        { "value": "```java\npublic void print(String s)\n```\nPrints a string to the standard output stream without a trailing newline. If the argument is null, the string `\"null\"` is printed." }
+      ]
+    },
+    "System.out.printf": {
+      "contents": [
+        { "value": "```java\npublic PrintStream printf(String format, Object... args)\n```\nWrites a formatted string to the output stream using the specified format string and arguments. Equivalent to `format(format, args)`." }
+      ]
+    },
+    "System.err.println": {
+      "contents": [
+        { "value": "```java\npublic void println(String x)\n```\nPrints a message to the standard error output stream followed by a newline. `System.err` is a `PrintStream` typically used for error messages and diagnostics." }
+      ]
+    },
+    "String.valueOf": {
+      "contents": [
+        { "value": "```java\npublic static String valueOf(Object obj)\npublic static String valueOf(int i)\npublic static String valueOf(char[] data)\n```\nReturns the string representation of the argument. If the argument is null, returns the string `\"null\"`. Overloaded for all primitive types, char arrays, and Objects." }
+      ]
+    },
+    "String.format": {
+      "contents": [
+        { "value": "```java\npublic static String format(String format, Object... args)\n```\nReturns a formatted string using the specified format string and arguments. Format specifiers include `%s` (string), `%d` (integer), `%f` (float), `%n` (newline), `%b` (boolean), and more." }
+      ]
+    },
+    "String.join": {
+      "contents": [
+        { "value": "```java\npublic static String join(CharSequence delimiter, CharSequence... elements)\npublic static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)\n```\nReturns a new String composed of the provided elements joined together with the specified delimiter." }
+      ]
+    },
+    "length": {
+      "contents": [
+        { "value": "```java\npublic int length()\n```\nReturns the length of this string. The length is equal to the number of Unicode code units (chars) in the string." }
+      ]
+    },
+    "charAt": {
+      "contents": [
+        { "value": "```java\npublic char charAt(int index)\n```\nReturns the `char` value at the specified index. An index ranges from 0 to `length() - 1`. Throws `StringIndexOutOfBoundsException` if the index is out of range." }
+      ]
+    },
+    "substring": {
+      "contents": [
+        { "value": "```java\npublic String substring(int beginIndex)\npublic String substring(int beginIndex, int endIndex)\n```\nReturns a substring starting at `beginIndex` (inclusive) and optionally ending at `endIndex` (exclusive). Throws `StringIndexOutOfBoundsException` if indices are out of range." }
+      ]
+    },
+    "equals": {
+      "contents": [
+        { "value": "```java\npublic boolean equals(Object anObject)\n```\nCompares this string to the specified object. Returns `true` if and only if the argument is a String with the same sequence of characters. Always use `.equals()` instead of `==` for String comparison." }
+      ]
+    },
+    "equalsIgnoreCase": {
+      "contents": [
+        { "value": "```java\npublic boolean equalsIgnoreCase(String anotherString)\n```\nCompares this String to another String, ignoring case considerations. Two strings are considered equal ignoring case if they are of the same length and corresponding characters are equal ignoring case." }
+      ]
+    },
+    "contains": {
+      "contents": [
+        { "value": "```java\npublic boolean contains(CharSequence s)\n```\nReturns true if this string contains the specified sequence of char values. Uses `indexOf` internally." }
+      ]
+    },
+    "startsWith": {
+      "contents": [
+        { "value": "```java\npublic boolean startsWith(String prefix)\npublic boolean startsWith(String prefix, int toffset)\n```\nTests if this string starts with the specified prefix, optionally beginning at the specified offset." }
+      ]
+    },
+    "endsWith": {
+      "contents": [
+        { "value": "```java\npublic boolean endsWith(String suffix)\n```\nTests if this string ends with the specified suffix." }
+      ]
+    },
+    "indexOf": {
+      "contents": [
+        { "value": "```java\npublic int indexOf(String str)\npublic int indexOf(String str, int fromIndex)\npublic int indexOf(int ch)\n```\nReturns the index within this string of the first occurrence of the specified character or substring. Returns `-1` if not found." }
+      ]
+    },
+    "replace": {
+      "contents": [
+        { "value": "```java\npublic String replace(char oldChar, char newChar)\npublic String replace(CharSequence target, CharSequence replacement)\n```\nReturns a string resulting from replacing all occurrences of `oldChar`/`target` with `newChar`/`replacement`. Does not use regex." }
+      ]
+    },
+    "replaceAll": {
+      "contents": [
+        { "value": "```java\npublic String replaceAll(String regex, String replacement)\n```\nReplaces each substring of this string that matches the given regular expression with the given replacement. Use `replace()` when regex is not needed." }
+      ]
+    },
+    "split": {
+      "contents": [
+        { "value": "```java\npublic String[] split(String regex)\npublic String[] split(String regex, int limit)\n```\nSplits this string around matches of the given regular expression. The `limit` parameter controls the number of times the pattern is applied." }
+      ]
+    },
+    "trim": {
+      "contents": [
+        { "value": "```java\npublic String trim()\n```\nReturns a string with leading and trailing whitespace removed, where whitespace is defined as any character whose codepoint is less than or equal to `'\\u0020'` (space). Consider using `strip()` for Unicode-aware trimming." }
+      ]
+    },
+    "strip": {
+      "contents": [
+        { "value": "```java\npublic String strip()\n```\n(Java 11+) Returns a string with all leading and trailing whitespace removed. Unlike `trim()`, this method uses `Character.isWhitespace()` and handles all Unicode whitespace." }
+      ]
+    },
+    "toUpperCase": {
+      "contents": [
+        { "value": "```java\npublic String toUpperCase()\npublic String toUpperCase(Locale locale)\n```\nConverts all characters in this String to upper case using the rules of the given or default Locale." }
+      ]
+    },
+    "toLowerCase": {
+      "contents": [
+        { "value": "```java\npublic String toLowerCase()\npublic String toLowerCase(Locale locale)\n```\nConverts all characters in this String to lower case using the rules of the given or default Locale." }
+      ]
+    },
+    "isEmpty": {
+      "contents": [
+        { "value": "```java\npublic boolean isEmpty()\n```\nReturns `true` if, and only if, `length()` is 0. Does not check for whitespace — use `isBlank()` for that." }
+      ]
+    },
+    "isBlank": {
+      "contents": [
+        { "value": "```java\npublic boolean isBlank()\n```\n(Java 11+) Returns `true` if the string is empty or contains only white space codepoints, as determined by `Character.isWhitespace()`." }
+      ]
+    },
+    "toCharArray": {
+      "contents": [
+        { "value": "```java\npublic char[] toCharArray()\n```\nConverts this string to a new character array. The length of the array equals the length of the string." }
+      ]
+    },
+    "matches": {
+      "contents": [
+        { "value": "```java\npublic boolean matches(String regex)\n```\nTells whether or not this string matches the given regular expression. An invocation of this method of the form `str.matches(regex)` yields the same result as `Pattern.matches(regex, str)`." }
+      ]
+    },
+    "List.of": {
+      "contents": [
+        { "value": "```java\nstatic <E> List<E> of(E... elements)\n```\n(Java 9+) Returns an unmodifiable list containing the specified elements. The list does not permit null elements. Throws `NullPointerException` if any element is null." }
+      ]
+    },
+    "List.copyOf": {
+      "contents": [
+        { "value": "```java\nstatic <E> List<E> copyOf(Collection<? extends E> coll)\n```\n(Java 10+) Returns an unmodifiable List containing the elements of the given Collection, in its iteration order. Does not permit null elements." }
+      ]
+    },
+    "ArrayList": {
+      "contents": [
+        { "value": "```java\npublic class ArrayList<E> extends AbstractList<E>\n    implements List<E>, RandomAccess, Cloneable, Serializable\n```\nResizable-array implementation of the `List` interface. Permits all elements, including null. Provides constant-time positional access and amortized constant-time add operations. Not synchronized." }
+      ]
+    },
+    "HashMap": {
+      "contents": [
+        { "value": "```java\npublic class HashMap<K,V> extends AbstractMap<K,V>\n    implements Map<K,V>, Cloneable, Serializable\n```\nHash table based implementation of the `Map` interface. Permits null keys and values. Makes no guarantees about iteration order. Provides constant-time performance for basic operations (get and put). Not synchronized." }
+      ]
+    },
+    "TreeMap": {
+      "contents": [
+        { "value": "```java\npublic class TreeMap<K,V> extends AbstractMap<K,V>\n    implements NavigableMap<K,V>, Cloneable, Serializable\n```\nA Red-Black tree based NavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time. Provides guaranteed log(n) time for get, put, and remove." }
+      ]
+    },
+    "HashSet": {
+      "contents": [
+        { "value": "```java\npublic class HashSet<E> extends AbstractSet<E>\n    implements Set<E>, Cloneable, Serializable\n```\nImplements the `Set` interface backed by a HashMap. Permits null elements. Makes no guarantees about iteration order. Offers constant time performance for basic operations (add, remove, contains, size)." }
+      ]
+    },
+    "Collections.sort": {
+      "contents": [
+        { "value": "```java\npublic static <T extends Comparable<? super T>> void sort(List<T> list)\npublic static <T> void sort(List<T> list, Comparator<? super T> c)\n```\nSorts the specified list into ascending order according to natural ordering or the specified Comparator. The sort is stable: equal elements are not reordered." }
+      ]
+    },
+    "Arrays.asList": {
+      "contents": [
+        { "value": "```java\npublic static <T> List<T> asList(T... a)\n```\nReturns a fixed-size list backed by the specified array. Changes to the returned list write through to the array. The returned list does not support add or remove operations." }
+      ]
+    },
+    "Arrays.sort": {
+      "contents": [
+        { "value": "```java\npublic static void sort(int[] a)\npublic static <T> void sort(T[] a, Comparator<? super T> c)\n```\nSorts the specified array into ascending numerical order. For object arrays, sorts according to the order induced by the specified Comparator. Uses dual-pivot Quicksort for primitives and TimSort for objects." }
+      ]
+    },
+    "Arrays.stream": {
+      "contents": [
+        { "value": "```java\npublic static <T> Stream<T> stream(T[] array)\npublic static IntStream stream(int[] array)\n```\nReturns a sequential Stream with the specified array as its source. Overloaded for primitive arrays (int, long, double) to return specialized streams." }
+      ]
+    },
+    "Map.of": {
+      "contents": [
+        { "value": "```java\nstatic <K,V> Map<K,V> of(K k1, V v1, ...)\n```\n(Java 9+) Returns an unmodifiable map containing the specified key-value pairs. Does not permit null keys or values. Throws `IllegalArgumentException` on duplicate keys. Supports up to 10 key-value pairs." }
+      ]
+    },
+    "Map.entry": {
+      "contents": [
+        { "value": "```java\nstatic <K,V> Map.Entry<K,V> entry(K k, V v)\n```\n(Java 9+) Returns an unmodifiable `Map.Entry` containing the given key and value. Neither the key nor the value may be null." }
+      ]
+    },
+    "Set.of": {
+      "contents": [
+        { "value": "```java\nstatic <E> Set<E> of(E... elements)\n```\n(Java 9+) Returns an unmodifiable set containing the specified elements. Does not permit null or duplicate elements." }
+      ]
+    },
+    "stream": {
+      "contents": [
+        { "value": "```java\ndefault Stream<E> stream()\n```\nReturns a sequential `Stream` with this collection as its source. Defined in `java.util.Collection`. The default implementation creates a sequential stream from the collection's `Spliterator`." }
+      ]
+    },
+    "filter": {
+      "contents": [
+        { "value": "```java\nStream<T> filter(Predicate<? super T> predicate)\n```\nReturns a stream consisting of the elements that match the given predicate. This is an intermediate operation." }
+      ]
+    },
+    "map": {
+      "contents": [
+        { "value": "```java\n<R> Stream<R> map(Function<? super T, ? extends R> mapper)\n```\nReturns a stream consisting of the results of applying the given function to the elements. This is an intermediate operation." }
+      ]
+    },
+    "flatMap": {
+      "contents": [
+        { "value": "```java\n<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)\n```\nReturns a stream consisting of the results of replacing each element with the contents of a mapped stream, effectively flattening nested structures. This is an intermediate operation." }
+      ]
+    },
+    "collect": {
+      "contents": [
+        { "value": "```java\n<R,A> R collect(Collector<? super T, A, R> collector)\n```\nPerforms a mutable reduction operation on the elements using a Collector. Common collectors include `Collectors.toList()`, `Collectors.toMap()`, `Collectors.groupingBy()`, and `Collectors.joining()`. This is a terminal operation." }
+      ]
+    },
+    "reduce": {
+      "contents": [
+        { "value": "```java\nOptional<T> reduce(BinaryOperator<T> accumulator)\nT reduce(T identity, BinaryOperator<T> accumulator)\n```\nPerforms a reduction on the elements using an associative accumulation function, and returns an Optional or identity-seeded result. This is a terminal operation." }
+      ]
+    },
+    "forEach": {
+      "contents": [
+        { "value": "```java\nvoid forEach(Consumer<? super T> action)\n```\nPerforms an action for each element of this stream. This is a terminal operation. The behavior is explicitly nondeterministic for parallel streams." }
+      ]
+    },
+    "sorted": {
+      "contents": [
+        { "value": "```java\nStream<T> sorted()\nStream<T> sorted(Comparator<? super T> comparator)\n```\nReturns a stream consisting of the elements sorted according to natural order or the provided Comparator. This is a stateful intermediate operation." }
+      ]
+    },
+    "distinct": {
+      "contents": [
+        { "value": "```java\nStream<T> distinct()\n```\nReturns a stream consisting of the distinct elements (according to `Object.equals(Object)`) of this stream. This is a stateful intermediate operation." }
+      ]
+    },
+    "Collectors.toList": {
+      "contents": [
+        { "value": "```java\npublic static <T> Collector<T, ?, List<T>> toList()\n```\nReturns a Collector that accumulates the input elements into a new `List`. There are no guarantees on the type, mutability, serializability, or thread-safety of the returned List." }
+      ]
+    },
+    "Collectors.toMap": {
+      "contents": [
+        { "value": "```java\npublic static <T, K, U> Collector<T, ?, Map<K,U>> toMap(\n    Function<? super T, ? extends K> keyMapper,\n    Function<? super T, ? extends U> valueMapper)\n```\nReturns a Collector that accumulates elements into a Map. Throws `IllegalStateException` on duplicate keys unless a merge function is provided." }
+      ]
+    },
+    "Collectors.groupingBy": {
+      "contents": [
+        { "value": "```java\npublic static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(\n    Function<? super T, ? extends K> classifier)\n```\nReturns a Collector implementing a \"group by\" operation, grouping elements according to the classifier function and returning a `Map<K, List<T>>`." }
+      ]
+    },
+    "Collectors.joining": {
+      "contents": [
+        { "value": "```java\npublic static Collector<CharSequence, ?, String> joining(CharSequence delimiter)\npublic static Collector<CharSequence, ?, String> joining(\n    CharSequence delimiter, CharSequence prefix, CharSequence suffix)\n```\nReturns a Collector that concatenates the input elements, separated by the specified delimiter, with optional prefix and suffix." }
+      ]
+    },
+    "Optional.of": {
+      "contents": [
+        { "value": "```java\npublic static <T> Optional<T> of(T value)\n```\nReturns an Optional describing the given non-null value. Throws `NullPointerException` if value is null. Use `ofNullable()` when the value may be null." }
+      ]
+    },
+    "Optional.ofNullable": {
+      "contents": [
+        { "value": "```java\npublic static <T> Optional<T> ofNullable(T value)\n```\nReturns an Optional describing the given value, or an empty Optional if the value is null." }
+      ]
+    },
+    "Optional.empty": {
+      "contents": [
+        { "value": "```java\npublic static <T> Optional<T> empty()\n```\nReturns an empty Optional instance. No value is present for this Optional." }
+      ]
+    },
+    "orElse": {
+      "contents": [
+        { "value": "```java\npublic T orElse(T other)\n```\nIf a value is present, returns the value, otherwise returns `other`. The `other` value is always evaluated — use `orElseGet()` for lazy evaluation." }
+      ]
+    },
+    "orElseGet": {
+      "contents": [
+        { "value": "```java\npublic T orElseGet(Supplier<? extends T> supplier)\n```\nIf a value is present, returns the value, otherwise invokes `supplier` and returns the result. Preferred over `orElse()` when the default is expensive to compute." }
+      ]
+    },
+    "orElseThrow": {
+      "contents": [
+        { "value": "```java\npublic T orElseThrow()\npublic <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)\n```\nIf a value is present, returns the value, otherwise throws `NoSuchElementException` (no-arg) or the exception created by the supplier." }
+      ]
+    },
+    "ifPresent": {
+      "contents": [
+        { "value": "```java\npublic void ifPresent(Consumer<? super T> action)\n```\nIf a value is present, performs the given action with the value, otherwise does nothing." }
+      ]
+    },
+    "CompletableFuture": {
+      "contents": [
+        { "value": "```java\npublic class CompletableFuture<T> implements Future<T>, CompletionStage<T>\n```\nA Future that may be explicitly completed and supports dependent functions, actions, and combinations. Provides a rich API for asynchronous programming including `supplyAsync`, `thenApply`, `thenCompose`, `exceptionally`, and more." }
+      ]
+    },
+    "Thread": {
+      "contents": [
+        { "value": "```java\npublic class Thread implements Runnable\n```\nA thread is a thread of execution in a program. The JVM allows an application to have multiple threads running concurrently. Every thread has a priority and optionally a name. Threads can be created by extending `Thread` or passing a `Runnable` to the constructor." }
+      ]
+    },
+    "ExecutorService": {
+      "contents": [
+        { "value": "```java\npublic interface ExecutorService extends Executor\n```\nAn Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of asynchronous tasks. Implementations include `ThreadPoolExecutor` and `ForkJoinPool`." }
+      ]
+    },
+    "Files.readString": {
+      "contents": [
+        { "value": "```java\npublic static String readString(Path path) throws IOException\npublic static String readString(Path path, Charset cs) throws IOException\n```\n(Java 11+) Reads all content from a file into a string, decoding from bytes to characters using the specified or UTF-8 charset." }
+      ]
+    },
+    "Files.writeString": {
+      "contents": [
+        { "value": "```java\npublic static Path writeString(Path path, CharSequence csq, OpenOption... options) throws IOException\n```\n(Java 11+) Write a CharSequence to a file. Characters are encoded into bytes using UTF-8 charset. Options may include StandardOpenOption.APPEND." }
+      ]
+    },
+    "Files.readAllLines": {
+      "contents": [
+        { "value": "```java\npublic static List<String> readAllLines(Path path) throws IOException\n```\nRead all lines from a file. Bytes from the file are decoded into characters using the UTF-8 charset. The returned list is modifiable." }
+      ]
+    },
+    "Path.of": {
+      "contents": [
+        { "value": "```java\npublic static Path of(String first, String... more)\n```\n(Java 11+) Returns a Path by converting a path string, or a sequence of strings that when joined form a path string. Throws `InvalidPathException` if the path string cannot be converted." }
+      ]
+    },
+    "Math.max": {
+      "contents": [
+        { "value": "```java\npublic static int max(int a, int b)\npublic static double max(double a, double b)\n```\nReturns the greater of two values. Overloaded for int, long, float, and double." }
+      ]
+    },
+    "Math.min": {
+      "contents": [
+        { "value": "```java\npublic static int min(int a, int b)\npublic static double min(double a, double b)\n```\nReturns the smaller of two values. Overloaded for int, long, float, and double." }
+      ]
+    },
+    "Math.abs": {
+      "contents": [
+        { "value": "```java\npublic static int abs(int a)\npublic static double abs(double a)\n```\nReturns the absolute value of the argument. Overloaded for int, long, float, and double." }
+      ]
+    },
+    "Math.sqrt": {
+      "contents": [
+        { "value": "```java\npublic static double sqrt(double a)\n```\nReturns the correctly rounded positive square root of a double value. If the argument is NaN or less than zero, the result is NaN." }
+      ]
+    },
+    "Math.pow": {
+      "contents": [
+        { "value": "```java\npublic static double pow(double a, double b)\n```\nReturns the value of the first argument raised to the power of the second argument." }
+      ]
+    },
+    "Math.random": {
+      "contents": [
+        { "value": "```java\npublic static double random()\n```\nReturns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0. Returned values are chosen pseudorandomly. Consider using `ThreadLocalRandom` or `java.util.Random` for more control." }
+      ]
+    },
+    "Integer.parseInt": {
+      "contents": [
+        { "value": "```java\npublic static int parseInt(String s) throws NumberFormatException\npublic static int parseInt(String s, int radix) throws NumberFormatException\n```\nParses the string argument as a signed integer in the specified radix (default 10). Throws `NumberFormatException` if the string does not contain a parsable integer." }
+      ]
+    },
+    "Integer.valueOf": {
+      "contents": [
+        { "value": "```java\npublic static Integer valueOf(String s) throws NumberFormatException\npublic static Integer valueOf(int i)\n```\nReturns an Integer instance representing the specified value. Values between -128 and 127 are cached." }
+      ]
+    },
+    "Double.parseDouble": {
+      "contents": [
+        { "value": "```java\npublic static double parseDouble(String s) throws NumberFormatException\n```\nReturns a new double initialized to the value represented by the specified String, as performed by `Double.valueOf(String)`." }
+      ]
+    },
+    "Objects.requireNonNull": {
+      "contents": [
+        { "value": "```java\npublic static <T> T requireNonNull(T obj)\npublic static <T> T requireNonNull(T obj, String message)\n```\nChecks that the specified object reference is not null. Throws `NullPointerException` with the optional message if the reference is null. Commonly used for parameter validation." }
+      ]
+    },
+    "Objects.equals": {
+      "contents": [
+        { "value": "```java\npublic static boolean equals(Object a, Object b)\n```\nReturns `true` if the arguments are equal to each other and `false` otherwise. Consequently, if both arguments are null, `true` is returned. Avoids NullPointerException." }
+      ]
+    }
+  }
+}