claude-dev-env 1.83.0 → 1.84.0

package/skills/test_markdown_link_integrity.py

@@ -0,0 +1,103 @@
+"""Link-integrity check for the skills tree and the shared pr-loop docs.
+
+Walks every markdown file under ``skills/`` and ``_shared/pr-loop/`` and
+resolves each relative markdown link target against the linking file's
+directory. A link whose target file or directory does not exist on disk is
+reported with its source file and line number, and the test fails.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+SKILLS_ROOT = Path(__file__).parent
+SHARED_PR_LOOP_ROOT = SKILLS_ROOT.parent / "_shared" / "pr-loop"
+
+MARKDOWN_LINK_PATTERN = re.compile(r"\]\(([^)\s]+)\)")
+FENCE_MARKER = "```"
+
+SKIPPED_TARGET_PREFIXES = (
+    "http://",
+    "https://",
+    "mailto:",
+    "#",
+    "/",
+    "$",
+    "~",
+    "<",
+)
+
+
+def _iter_markdown_files() -> list[Path]:
+    """List every markdown file the integrity check covers.
+
+    Returns:
+        All ``.md`` files under the skills tree and the shared pr-loop tree.
+    """
+    all_markdown_files = sorted(SKILLS_ROOT.rglob("*.md"))
+    all_markdown_files.extend(sorted(SHARED_PR_LOOP_ROOT.rglob("*.md")))
+    return all_markdown_files
+
+
+def _is_checkable_target(link_target: str) -> bool:
+    """Decide whether a markdown link target names a local relative path.
+
+    Args:
+        link_target: The raw text between ``](`` and ``)`` in a markdown link.
+
+    Returns:
+        True when the target is a relative filesystem path this check can
+        resolve; False for URLs, anchors, absolute paths, environment-variable
+        paths, home-relative paths, and angle-bracket placeholders.
+    """
+    if link_target.startswith(SKIPPED_TARGET_PREFIXES):
+        return False
+    if "\\" in link_target and link_target.count(":") > 0:
+        return False
+    return True
+
+
+def _collect_broken_links(markdown_path: Path) -> list[str]:
+    """Resolve every relative link in one markdown file.
+
+    Fenced code blocks are skipped, and a ``#fragment`` suffix is stripped
+    before resolution.
+
+    Args:
+        markdown_path: The markdown file whose links are resolved.
+
+    Returns:
+        One ``file:line -> target`` description per unresolvable link.
+    """
+    all_broken_links: list[str] = []
+    is_inside_fence = False
+    for line_number, each_line in enumerate(
+        markdown_path.read_text(encoding="utf-8").splitlines(), start=1
+    ):
+        if each_line.lstrip().startswith(FENCE_MARKER):
+            is_inside_fence = not is_inside_fence
+            continue
+        if is_inside_fence:
+            continue
+        for each_match in MARKDOWN_LINK_PATTERN.finditer(each_line):
+            link_target = each_match.group(1).split("#", 1)[0]
+            if not link_target or not _is_checkable_target(link_target):
+                continue
+            resolved_target = (markdown_path.parent / link_target).resolve()
+            if not resolved_target.exists():
+                all_broken_links.append(
+                    f"{markdown_path}:{line_number} -> {each_match.group(1)}"
+                )
+    return all_broken_links
+
+
+def test_every_relative_markdown_link_resolves() -> None:
+    all_broken_links: list[str] = []
+    for each_markdown_path in _iter_markdown_files():
+        all_broken_links.extend(_collect_broken_links(each_markdown_path))
+    broken_link_report = "\n".join(all_broken_links)
+    assert not all_broken_links, (
+        f"Unresolvable relative markdown links:\n{broken_link_report}"
+    )

package/commands/doc-gist.md

@@ -1,16 +0,0 @@
----
-description: Upload an HTML file as a secret gist and open the htmlpreview URL. Manual escape hatch when the auto-publish hook's marker route doesn't apply.
-allowed-tools: Bash
----
-
-Argument: `$ARGUMENTS` is the path to an existing `.html` file.
-
-Run the doc-gist skill's transport script directly:
-
-```
-python3 "${CLAUDE_PLUGIN_ROOT}/skills/doc-gist/scripts/gist_upload.py" --input "$ARGUMENTS"
-```
-
-Quote both URLs (`Gist:` and `Preview:`) from stderr back to the user as clickable markdown links. Surface any `gh gist create failed` error with the suggested `gh auth login` next-step.
-
-When the user asks for a writeup or report rather than handing you a file path, design fresh HTML per [`skills/doc-gist/SKILL.md`](../skills/doc-gist/SKILL.md), include the `<!-- @publish-as-gist -->` marker, and write the file — the auto-publish hook will run on Write. Use this command only when the marker route doesn't fit (existing file you want to publish, HTML from a separate tool).

package/hooks/blocking/_md_to_html_blocker_test_support.py

@@ -1,65 +0,0 @@
-"""Shared subprocess-invocation helpers for the md_to_html_blocker test suites.
-
-Subprocess CWD is rooted in a per-session sandbox created lazily so that
-relative-path test cases canonicalize outside any `.claude-plugin/` ancestor,
-outside the OS temp directory, and outside the exempt home-relative
-subdirectories. The sandbox is a real repo root (it carries a `.git` marker) so
-relative `README.md` / `CHANGELOG.md` writes exercise the repo-root exemption
-path. This keeps the suites independent of where pytest itself is run.
-"""
-
-import functools
-import json
-import os
-import shutil
-import stat
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-
-HOOK_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "md_to_html_blocker.py")
-
-
-def _strip_read_only_and_retry(removal_function, target_path, *_exc_info):
-    try:
-        os.chmod(target_path, stat.S_IWRITE)
-        removal_function(target_path)
-    except OSError:
-        pass
-
-
-def _force_rmtree(target_path: str) -> None:
-    handler_kw = (
-        {"onexc": _strip_read_only_and_retry}
-        if sys.version_info >= (3, 12)
-        else {"onerror": _strip_read_only_and_retry}
-    )
-    try:
-        shutil.rmtree(target_path, **handler_kw)
-    except OSError:
-        pass
-
-
-@functools.lru_cache(maxsize=1)
-def _get_sandbox_parent_directory() -> str:
-    sandbox_parent = tempfile.mkdtemp(prefix="pytest_md_blocker_", dir=str(Path.home()))
-    git_marker_path = os.path.join(sandbox_parent, ".git")
-    Path(git_marker_path).touch()
-    return sandbox_parent
-
-
-class _RunHook:
-    def __call__(self, tool_name: str, tool_input: dict) -> subprocess.CompletedProcess:
-        payload = json.dumps({"tool_name": tool_name, "tool_input": tool_input})
-        return subprocess.run(
-            [sys.executable, HOOK_SCRIPT_PATH],
-            input=payload,
-            capture_output=True,
-            text=True,
-            check=False,
-            cwd=_get_sandbox_parent_directory(),
-        )
-
-
-_run_hook = _RunHook()

package/hooks/blocking/conftest.py

@@ -1,30 +0,0 @@
-"""Session-scoped cleanup fixture for the md_to_html_blocker test suites.
-
-The md_to_html_blocker suites share one lazily-created sandbox parent
-directory under the home directory. This fixture tears that sandbox down once
-the session ends so the suites leave no residue regardless of which split file
-pytest collects first.
-"""
-
-import sys
-from pathlib import Path
-
-import pytest
-
-_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
-
-if str(_BLOCKING_DIRECTORY) not in sys.path:
-    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
-
-from _md_to_html_blocker_test_support import (  # noqa: E402
-    _force_rmtree,
-    _get_sandbox_parent_directory,
-)
-
-
-@pytest.fixture(scope="session", autouse=True)
-def _cleanup_sandbox_parent_directory():
-    yield
-    if _get_sandbox_parent_directory.cache_info().currsize:
-        _force_rmtree(_get_sandbox_parent_directory())
-        _get_sandbox_parent_directory.cache_clear()

package/hooks/blocking/md_path_exemptions.py

@@ -1,224 +0,0 @@
-"""Shared exemption rules for the .md blocker and its post-write companion.
-
-Both `md_to_html_blocker.py` (PreToolUse) and `md_to_html_companion.py`
-(PostToolUse) must agree on which file paths bypass the .md → .html policy.
-This module is the single source of truth for that decision.
-"""
-
-import os
-import sys
-from pathlib import Path, PureWindowsPath
-
-
-_hooks_directory = str(Path(__file__).resolve().parent.parent)
-if _hooks_directory not in sys.path:
-    sys.path.insert(0, _hooks_directory)
-
-from hooks_constants.md_to_html_blocker_constants import (  # noqa: E402
-    ALL_CLAUDE_CODE_SOURCE_TOP_DIRECTORIES,
-    ALL_EXEMPT_ANYWHERE_FILENAMES_LOWER,
-    ALL_EXEMPT_HOME_DIRECTORY_PATH_PREFIXES,
-    ALL_EXEMPT_PLUGIN_DIRECTORY_SEGMENTS,
-    ALL_EXEMPT_ROOT_FILENAMES_LOWER,
-    CLAUDE_DEV_ENV_REPO_NAME_SEGMENT,
-    CLAUDE_DIRECTORY_NAME,
-    CLAUDE_PROFILE_DIRECTORY_NAME_PREFIX,
-    MINIMUM_SEGMENT_COUNT_TO_MATCH_INDICATOR,
-    PACKAGES_TOP_LEVEL_SEGMENT,
-    PLUGIN_ROOT_MARKER_DIRECTORY_NAME,
-    REPO_ROOT_MARKER_NAME,
-    RESOLVED_HOME_DIRECTORY_LOWER,
-    RESOLVED_TEMP_DIRECTORY_PATH_PREFIX,
-)
-
-
-def is_exempt_path(file_path: str) -> bool:
-    """Return True when the .md file path is exempt from the blocker policy.
-
-    Exemption sources, in order of evaluation:
-    - Any directory segment named `.claude` or prefixed `.claude-`
-      (case-insensitive): project infrastructure, profile directories like
-      `.claude-mel/`, and `.claude-plugin/`
-    - Basename in `ALL_EXEMPT_ANYWHERE_FILENAMES` (e.g. SKILL.md)
-    - Anchored under `packages/claude-dev-env/<one of
-      ALL_CLAUDE_CODE_SOURCE_TOP_DIRECTORIES>/...` (docs, rules,
-      system-prompts source files in this repo)
-    - Path segment in `ALL_EXEMPT_PLUGIN_DIRECTORY_SEGMENTS` (agents/skills/commands)
-    - Canonical path under a home-relative exempt directory
-      (`ALL_EXEMPT_HOME_RELATIVE_DIRECTORIES`)
-    - Canonical path under the OS temp directory
-    - Ancestor directory contains `.claude-plugin/` (plugin-root marker walk)
-    - Basename in `ALL_EXEMPT_ROOT_FILENAMES` and directory is a repo root
-
-    Args:
-        file_path: Raw file path from the hook payload. May contain tilde,
-            backslashes, or be relative.
-
-    Returns:
-        True when the path is exempt, False when the policy applies.
-    """
-    expanded_path = os.path.expanduser(file_path)
-    normalized = os.path.normpath(expanded_path).replace("\\", "/")
-    lower_normalized = normalized.lower()
-    if _has_claude_infrastructure_segment(lower_normalized):
-        return True
-    basename_lower = os.path.basename(normalized).lower()
-    if basename_lower in ALL_EXEMPT_ANYWHERE_FILENAMES_LOWER:
-        return True
-    if _is_under_claude_dev_env_source_subdirectory(expanded_path, lower_normalized):
-        return True
-    if _has_plugin_directory_segment(lower_normalized):
-        return True
-    canonical_normalized_path = os.path.realpath(expanded_path).replace("\\", "/")
-    canonical_lower_path = canonical_normalized_path.lower()
-    if _is_under_exempt_home_directory(canonical_lower_path):
-        return True
-    if canonical_lower_path.startswith(RESOLVED_TEMP_DIRECTORY_PATH_PREFIX):
-        return True
-    if _is_under_plugin_root_marker(canonical_normalized_path):
-        return True
-    if basename_lower in ALL_EXEMPT_ROOT_FILENAMES_LOWER:
-        absolute_directory = _resolve_absolute_directory(normalized)
-        if _is_repo_root_directory(absolute_directory):
-            return True
-    return False
-
-
-def _resolve_absolute_directory(normalized_path: str) -> str:
-    directory = os.path.dirname(normalized_path)
-    if not directory or directory == ".":
-        return os.getcwd()
-    if os.path.isabs(directory):
-        return directory
-    return os.path.abspath(directory)
-
-
-def _has_claude_infrastructure_segment(lower_normalized_path: str) -> bool:
-    """A directory named `.claude` or prefixed `.claude-` (profile and
-    plugin directories) holds Claude infrastructure; any path inside one
-    is exempt.
-
-    Only directory segments are matched. The final segment is always the
-    file's basename (``normpath`` strips any trailing slash), so a file
-    merely named with the ``.claude-`` prefix in an ordinary directory
-    stays subject to the policy.
-
-    Args:
-        lower_normalized_path: Lowercased path with separators normalized
-            to forward slashes.
-
-    Returns:
-        True when any directory segment names a Claude infrastructure
-        directory.
-    """
-    all_directory_segments = lower_normalized_path.split("/")[:-1]
-    for each_segment in all_directory_segments:
-        if each_segment == CLAUDE_DIRECTORY_NAME:
-            return True
-        if each_segment.startswith(CLAUDE_PROFILE_DIRECTORY_NAME_PREFIX):
-            return True
-    return False
-
-
-def _has_plugin_directory_segment(lower_normalized_path: str) -> bool:
-    for each_directory_segment in ALL_EXEMPT_PLUGIN_DIRECTORY_SEGMENTS:
-        segment_marker = f"/{each_directory_segment}/"
-        if segment_marker in lower_normalized_path:
-            return True
-        if lower_normalized_path.startswith(f"{each_directory_segment}/"):
-            return True
-    return False
-
-
-def _is_absolute_path_cross_platform(file_path: str) -> bool:
-    """Detect absolute paths in both POSIX and Windows drive-letter forms.
-
-    ``os.path.isabs`` is platform-dependent: on Linux/macOS it classifies a
-    Windows drive-letter path like ``Y:\\repo\\foo`` as relative. The anchored
-    source-subdirectory exemption must scan every starting segment for
-    absolute paths regardless of host OS, so a path's absoluteness must be
-    decided cross-platform.
-
-    Args:
-        file_path: Tilde-expanded file path.
-
-    Returns:
-        True when the path is absolute under POSIX rules or carries a Windows
-        drive-letter root (``[A-Za-z]:[\\\\/]...``).
-    """
-    if os.path.isabs(file_path):
-        return True
-    return PureWindowsPath(file_path).is_absolute()
-
-
-def _is_under_claude_dev_env_source_subdirectory(
-    expanded_file_path: str, lower_normalized_path: str
-) -> bool:
-    """Anchored exemption for ``packages/claude-dev-env/<source-dir>/...``.
-
-    The match requires segment-anchored matching at the start of the path
-    (relative) or at the root of an absolute path. A nested path like
-    ``notes/packages/claude-dev-env/docs/foo.md`` is NOT exempt — only the
-    full three-segment anchor matches.
-
-    Args:
-        expanded_file_path: Tilde-expanded file path; ``os.path.isabs`` on
-            this form classifies the path as absolute or relative on the
-            current platform.
-        lower_normalized_path: Same path lowercased and with separators
-            normalized to forward slashes.
-
-    Returns:
-        True when the path is anchored under
-        ``packages/claude-dev-env/<one of
-        ALL_CLAUDE_CODE_SOURCE_TOP_DIRECTORIES>/``.
-    """
-    all_segments = [
-        each_segment
-        for each_segment in lower_normalized_path.split("/")
-        if each_segment
-    ]
-    if not all_segments:
-        return False
-    if _is_absolute_path_cross_platform(expanded_file_path):
-        starting_segment_index_options = list(range(len(all_segments)))
-    else:
-        starting_segment_index_options = [0]
-    for each_starting_index in starting_segment_index_options:
-        if (
-            len(all_segments) >= each_starting_index + MINIMUM_SEGMENT_COUNT_TO_MATCH_INDICATOR
-            and all_segments[each_starting_index] == PACKAGES_TOP_LEVEL_SEGMENT
-            and all_segments[each_starting_index + 1] == CLAUDE_DEV_ENV_REPO_NAME_SEGMENT
-            and all_segments[each_starting_index + 2] in ALL_CLAUDE_CODE_SOURCE_TOP_DIRECTORIES
-        ):
-            return True
-    return False
-
-
-def _is_under_plugin_root_marker(normalized_path: str) -> bool:
-    directory = os.path.dirname(normalized_path)
-    visited_directories: set[str] = set()
-    while directory and directory not in visited_directories:
-        visited_directories.add(directory)
-        marker_path = os.path.join(directory, PLUGIN_ROOT_MARKER_DIRECTORY_NAME)
-        if os.path.isdir(marker_path):
-            return True
-        parent_directory = os.path.dirname(directory)
-        if parent_directory == directory:
-            break
-        directory = parent_directory
-    return False
-
-
-def _is_under_exempt_home_directory(lower_normalized_path: str) -> bool:
-    if not RESOLVED_HOME_DIRECTORY_LOWER:
-        return False
-    for each_exempt_path_prefix in ALL_EXEMPT_HOME_DIRECTORY_PATH_PREFIXES:
-        if lower_normalized_path.startswith(each_exempt_path_prefix):
-            return True
-    return False
-
-
-def _is_repo_root_directory(directory_path: str) -> bool:
-    git_marker_path = os.path.join(directory_path, REPO_ROOT_MARKER_NAME)
-    return os.path.exists(git_marker_path)

package/hooks/blocking/md_to_html_blocker.py

@@ -1,155 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: blocks Write/Edit targeting .md files, redirecting to .html.
-
-HTML preserves spatial structure (diffs, timelines, comparisons, diagrams)
-that markdown flattens. See https://thariqs.github.io/html-effectiveness/
-"""
-
-import json
-import sys
-from pathlib import Path
-from typing import TextIO
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-_blocking_directory = str(Path(__file__).resolve().parent)
-if _blocking_directory not in sys.path:
-    sys.path.insert(0, _blocking_directory)
-
-from md_path_exemptions import is_exempt_path  # noqa: E402
-
-from hooks_constants.md_to_html_blocker_constants import (  # noqa: E402
-    ALL_CLAUDE_CODE_SOURCE_TOP_DIRECTORIES,
-    ALL_EXEMPT_ANYWHERE_FILENAMES,
-    ALL_EXEMPT_HOME_RELATIVE_DIRECTORIES,
-    ALL_EXEMPT_PLUGIN_DIRECTORY_SEGMENTS,
-    CLAUDE_DEV_ENV_REPO_NAME_SEGMENT,
-    CLAUDE_DIRECTORY_NAME,
-    CLAUDE_PROFILE_DIRECTORY_NAME_PREFIX,
-    PACKAGES_TOP_LEVEL_SEGMENT,
-    PLUGIN_ROOT_MARKER_DIRECTORY_NAME,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
-    read_hook_input_dictionary_from_stdin,
-)
-
-_markdown_extension = ".md"
-_html_effectiveness_url = "https://thariqs.github.io/html-effectiveness/"
-_exempt_anywhere_filenames_summary = ", ".join(ALL_EXEMPT_ANYWHERE_FILENAMES)
-_exempt_plugin_segments_summary = ", ".join(
-    f"{each_segment}/" for each_segment in ALL_EXEMPT_PLUGIN_DIRECTORY_SEGMENTS
-)
-_exempt_home_directories_summary = ", ".join(
-    f"~/{each_directory}/" for each_directory in ALL_EXEMPT_HOME_RELATIVE_DIRECTORIES
-)
-_claude_dev_env_source_directories_summary = (
-    f"{PACKAGES_TOP_LEVEL_SEGMENT}/{CLAUDE_DEV_ENV_REPO_NAME_SEGMENT}/"
-    f"{{{','.join(sorted(ALL_CLAUDE_CODE_SOURCE_TOP_DIRECTORIES))}}}/"
-)
-
-
-def _block_reason(file_path: str) -> str:
-    return (
-        f"BLOCKED: Write/Edit to .md file '{file_path}' is not permitted. "
-        "Use .html files instead for documentation. "
-        f"See {_html_effectiveness_url} for why HTML "
-        "is more effective than Markdown for structured information."
-    )
-
-
-def _block_context() -> str:
-    return (
-        "Generate a self-contained .html file instead of .md. "
-        "Design freely — HTML can express spatial structure, interactivity, "
-        "and visual hierarchy that markdown cannot.\n\n"
-        "Reference for HTML effectiveness patterns:\n"
-        f"{_html_effectiveness_url}\n"
-        "Exceptions (.md still allowed):\n"
-        f"- Files inside {CLAUDE_DIRECTORY_NAME}/ or {CLAUDE_PROFILE_DIRECTORY_NAME_PREFIX}*/ directories\n"
-        f"- {_exempt_anywhere_filenames_summary} anywhere\n"
-        f"- Files under {_exempt_plugin_segments_summary} directories\n"
-        f"- Files under {_claude_dev_env_source_directories_summary} source directories\n"
-        f"- Files under any directory whose ancestor contains {PLUGIN_ROOT_MARKER_DIRECTORY_NAME}/\n"
-        "- README.md, CHANGELOG.md, CLAUDE.md, and AGENTS.md at any repo root\n"
-        f"- Files under {_exempt_home_directories_summary}\n"
-        "- Files under the OS temp directory"
-    )
-
-
-def _block_system_message() -> str:
-    return (
-        ".md files are blocked in this project — generate a self-contained .html "
-        f"file instead. See {_html_effectiveness_url} for "
-        f"design patterns and examples. Exemptions: {CLAUDE_DIRECTORY_NAME}/ and "
-        f"{CLAUDE_PROFILE_DIRECTORY_NAME_PREFIX}*/ infrastructure, "
-        f"{_exempt_anywhere_filenames_summary} anywhere, {_exempt_plugin_segments_summary} trees, "
-        f"{_claude_dev_env_source_directories_summary} source trees, "
-        f"files under a {PLUGIN_ROOT_MARKER_DIRECTORY_NAME}/ root, "
-        f"README.md/CHANGELOG.md/CLAUDE.md/AGENTS.md at any repo root, {_exempt_home_directories_summary}, "
-        "and the OS temp directory."
-    )
-
-
-def main() -> None:
-    """Read hook input JSON from stdin, deny .md writes or pass through silently.
-
-    Returns:
-        None (exits process).
-    """
-    input_data = read_hook_input_dictionary_from_stdin()
-    if input_data is None:
-        sys.exit(0)
-
-    tool_name = input_data.get("tool_name", "")
-    if not isinstance(tool_name, str):
-        sys.exit(0)
-
-    tool_input = input_data.get("tool_input", {})
-    if not isinstance(tool_input, dict):
-        sys.exit(0)
-
-    if tool_name not in ("Write", "Edit"):
-        sys.exit(0)
-
-    file_path = tool_input.get("file_path", "")
-    if not file_path:
-        sys.exit(0)
-
-    if not file_path.lower().endswith(_markdown_extension):
-        sys.exit(0)
-
-    if is_exempt_path(file_path):
-        sys.exit(0)
-
-    deny_reason = _block_reason(file_path)
-    block_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": deny_reason,
-            "additionalContext": _block_context(),
-        },
-        "systemMessage": _block_system_message(),
-        "suppressOutput": True,
-    }
-    log_hook_block(
-        calling_hook_name="md_to_html_blocker.py",
-        hook_event="PreToolUse",
-        block_reason=deny_reason,
-        tool_name=tool_name,
-        offending_input_preview=file_path,
-    )
-    _emit_hook_result(block_payload, sys.stdout)
-    sys.exit(0)
-
-
-def _emit_hook_result(all_hook_data: dict, output_stream: TextIO) -> None:
-    output_stream.write(json.dumps(all_hook_data) + "\n")
-    output_stream.flush()
-
-
-if __name__ == "__main__":
-    main()