@xpack/doxygen2docusaurus 2.0.0 → 2.2.0

package/dist/docusaurus/renderers/descriptiontype.js

@@ -1,15 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/*
- * This file is part of the xPack project (http://xpack.github.io).
- * Copyright (c) 2025 Liviu Ionescu. All rights reserved.
- *
- * Permission to use, copy, modify, and/or distribute this software
- * for any purpose is hereby granted, under the terms of the MIT license.
- *
- * If a copy of the license was not distributed with this file, it can
- * be obtained from https://opensource.org/licenses/MIT.
- */
-// ----------------------------------------------------------------------------
 import assert from 'node:assert';
 import util from 'node:util';
 import { ElementLinesRendererBase, ElementStringRendererBase, } from './element-renderer-base.js';
@@ -19,20 +7,8 @@ import { getPermalinkAnchor, isUrl, stripLeadingAndTrailingNewLines, } from '../
 import { AbstractDocHtmlOnlyType, LatexOnlyDataModel, ManOnlyDataModel, RtfOnlyDataModel, XmlOnlyDataModel, } from '../../doxygen/data-model/compounds/compounddef-dm.js';
 import { renderParagraphs } from '../cli-options.js';
 import { AbstractDataModelBase } from '../../doxygen/data-model/types.js';
-// ----------------------------------------------------------------------------
-/**
- * Primary renderer for description type elements in documentation.
- *
- * @remarks
- * Handles the rendering of Doxygen description elements that contain
- * formatted text, converting them into appropriate output lines for
- * documentation generation. Supports both brief and detailed descriptions.
- *
- * @public
- */
 export class DescriptionTypeLinesRenderer extends ElementLinesRendererBase {
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         if (element.title !== undefined && element.title.length > 0) {
             console.error('title ignored in', element.constructor.name);
         }
@@ -41,52 +17,22 @@ export class DescriptionTypeLinesRenderer extends ElementLinesRendererBase {
         return lines;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for Doxygen paragraph elements in documentation.
- *
- * @remarks
- * Handles the complex rendering of paragraph elements that can contain
- * mixed content including text, markup, links, and block-level elements.
- * Manages paragraph boundaries and applies appropriate HTML wrapping.
- *
- * @public
- */
 export class DocParaTypeLinesRenderer extends ElementLinesRendererBase {
-    /**
-     * Renders a paragraph element to formatted output lines.
-     *
-     * @remarks
-     * Processes child elements to determine paragraph boundaries and applies
-     * appropriate HTML paragraph tags when enabled. Handles mixed content
-     * including inline elements and block-level elements with proper spacing.
-     *
-     * @param element - The paragraph element to render
-     * @param type - The rendering context type
-     * @returns Array of formatted output lines with paragraph structure
-     */
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
-        // console.log(element)
         const lines = [];
         let inParagraph = false;
         let text = '';
         assert(element.children !== undefined);
         for (const child of element.children) {
-            // console.log(child)
             if (this.isParagraph(child)) {
                 inParagraph = true;
-                text += this.workspace.renderElementToString(child, 
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                renderParagraphs ? 'html' : type);
+                text += this.workspace.renderElementToString(child, renderParagraphs ? 'html' : type);
             }
             else {
                 if (inParagraph) {
                     text = text.trim();
-                    // console.log(text)
                     if (text.length > 0) {
                         lines.push('');
-                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                         if ((element.skipPara ?? false) || !renderParagraphs) {
                             lines.push(text);
                         }
@@ -103,10 +49,8 @@ export class DocParaTypeLinesRenderer extends ElementLinesRendererBase {
         }
         if (inParagraph) {
             text = text.trim();
-            // console.log(text)
             if (text.length > 0) {
                 lines.push('');
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                 if ((element.skipPara ?? false) || !renderParagraphs) {
                     lines.push(text);
                 }
@@ -116,44 +60,29 @@ export class DocParaTypeLinesRenderer extends ElementLinesRendererBase {
                 }
             }
         }
-        // console.log(lines)
         return lines;
     }
-    // docCmdGroup: 2109
-    /**
-     * Determines if an element should be rendered within a paragraph context.
-     *
-     * @remarks
-     * Classifies documentation elements as either inline (paragraph content)
-     * or block-level elements. This classification controls whether elements
-     * are wrapped in paragraph tags or rendered as standalone blocks.
-     *
-     * @param element - The element to classify
-     * @returns True if the element should be rendered within a paragraph
-     */
     isParagraph(element) {
         if (typeof element === 'string') {
             return true;
         }
         else if (element instanceof HrulerDataModel) {
-            return false; // Explicitly not inside a paragraph.
-            // } else if (element instanceof LineBreakDataModel) {
-            //   return false // Explicitly not inside a paragraph.
+            return false;
         }
         else if (element instanceof AbstractDocHtmlOnlyType) {
-            return false; // Explicitly not inside a paragraph.
+            return false;
         }
         else if (element instanceof ManOnlyDataModel) {
-            return false; // Explicitly not inside a paragraph.
+            return false;
         }
         else if (element instanceof XmlOnlyDataModel) {
-            return false; // Explicitly not inside a paragraph.
+            return false;
         }
         else if (element instanceof RtfOnlyDataModel) {
-            return false; // Explicitly not inside a paragraph.
+            return false;
         }
         else if (element instanceof LatexOnlyDataModel) {
-            return false; // Explicitly not inside a paragraph.
+            return false;
         }
         else if (element instanceof AbstractDocURLLink) {
             return true;
@@ -163,10 +92,6 @@ export class DocParaTypeLinesRenderer extends ElementLinesRendererBase {
         }
         else if (element instanceof AbstractDocImageType) {
             return true;
-            // Not defined yet.
-            //  <xsd:element name="dot" type="docDotMscType" />
-            //  <xsd:element name="msc" type="docDotMscType" />
-            //  <xsd:element name="plantuml" type="docPlantumlType" />
         }
         else if (element instanceof AbstractDocAnchorType) {
             return true;
@@ -183,36 +108,11 @@ export class DocParaTypeLinesRenderer extends ElementLinesRendererBase {
         else if (element instanceof AbstractDocEmptyType) {
             return true;
         }
-        // The rest, from "programlisting" on, are not paragraphs.
         return false;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for URL link elements in documentation.
- *
- * @remarks
- * Converts Doxygen URL link elements to HTML anchor tags with proper
- * href attributes. Processes child elements to generate the link text
- * content while preserving formatting.
- *
- * @public
- */
 export class DocURLLinkStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a URL link element to a formatted HTML anchor string.
-     *
-     * @remarks
-     * Creates an HTML anchor element with the specified URL and renders
-     * child elements as the link text content. Maintains proper link
-     * structure for external and internal references.
-     *
-     * @param element - The URL link element to render
-     * @param type - The rendering context type
-     * @returns The formatted HTML anchor string
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         text += `<a href="${element.url}">`;
         text += this.workspace.renderElementsArrayToString(element.children, type);
@@ -220,7 +120,6 @@ export class DocURLLinkStringRenderer extends ElementStringRendererBase {
         return text;
     }
 }
-// ----------------------------------------------------------------------------
 const htmlElements = {
     BoldDataModel: 'b',
     EmphasisDataModel: 'em',
@@ -228,33 +127,9 @@ const htmlElements = {
     SubscriptDataModel: 'sub',
     SuperscriptDataModel: 'sup',
 };
-/**
- * Renderer for text markup elements in documentation.
- *
- * @remarks
- * Handles common text formatting elements such as bold, emphasis, underline,
- * subscript, and superscript. Maps Doxygen markup types to appropriate
- * HTML elements for consistent text formatting.
- *
- * @public
- */
 export class DocMarkupTypeStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a markup element to a formatted HTML string.
-     *
-     * @remarks
-     * Converts Doxygen markup elements to their corresponding HTML tags
-     * and processes child content. Supports standard formatting elements
-     * with error handling for unrecognised markup types.
-     *
-     * @param element - The markup element to render
-     * @param type - The rendering context type
-     * @returns The formatted HTML string with markup tags
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         const htmlElement = htmlElements[element.constructor.name];
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (htmlElement === undefined) {
             console.error(util.inspect(element, { compact: false, depth: 999 }));
             console.error(element.constructor.name, 'not yet rendered in', this.constructor.name);
@@ -267,69 +142,17 @@ export class DocMarkupTypeStringRenderer extends ElementStringRendererBase {
         return text;
     }
 }
-/**
- * Renderer for computer output or code text elements.
- *
- * @remarks
- * Formats text as computer output using CSS styling rather than code blocks.
- * Handles inline code formatting that may contain HTML elements while
- * maintaining compatibility with Docusaurus rendering.
- *
- * @public
- */
 export class ComputerOutputDataModelStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders computer output text to a formatted HTML string.
-     *
-     * @remarks
-     * Wraps content in a styled span element for computer output formatting.
-     * Uses CSS classes instead of code blocks to handle mixed content
-     * including HTML elements like anchors.
-     *
-     * @param element - The computer output element to render
-     * @param type - The rendering context type
-     * @returns The formatted HTML string with computer output styling
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
-        // Cannot use `...` since it may include html code (like <a>).
-        // Cannot use <code> since Docusaurus renders it as a block if it includes
-        // other elements like <a>.
         text += '<span class="doxyComputerOutput">';
-        // Inherit type, do not use 'html' since Docusaurus may parse
-        // it as markdown.
         text += this.workspace.renderElementsArrayToString(element.children, type);
         text += '</span>';
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for reference text elements within descriptions.
- *
- * @remarks
- * Handles cross-references to other documentation elements by generating
- * appropriate links when permalinks are available. Provides fallback
- * text rendering for unresolved references.
- *
- * @public
- */
 export class DocRefTextTypeStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a reference text element to a formatted string with linking.
-     *
-     * @remarks
-     * Creates HTML anchor tags for valid references with permalinks,
-     * otherwise renders as plain text. Logs warnings for unsupported
-     * external references that are not yet implemented.
-     *
-     * @param element - The reference text element to render
-     * @param type - The rendering context type
-     * @returns The formatted string with optional link
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         if (element.external !== undefined && element.external.length > 0) {
             console.error('external ignored in', element.constructor.name);
         }
@@ -352,56 +175,9 @@ export class DocRefTextTypeStringRenderer extends ElementStringRendererBase {
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-// <xsd:simpleType name="DoxSimpleSectKind">
-//   <xsd:restriction base="xsd:string">
-//     <xsd:enumeration value="see" />
-//     <xsd:enumeration value="return" />
-//     <xsd:enumeration value="author" />
-//     <xsd:enumeration value="authors" />
-//     <xsd:enumeration value="version" />
-//     <xsd:enumeration value="since" />
-//     <xsd:enumeration value="date" />
-//     <xsd:enumeration value="note" />
-//     <xsd:enumeration value="warning" />
-//     <xsd:enumeration value="pre" />
-//     <xsd:enumeration value="post" />
-//     <xsd:enumeration value="copyright" />
-//     <xsd:enumeration value="invariant" />
-//     <xsd:enumeration value="remark" />
-//     <xsd:enumeration value="attention" />
-//     <xsd:enumeration value="important" />
-//     <xsd:enumeration value="par" />
-//     <xsd:enumeration value="rcs" />
-//   </xsd:restriction>
-// </xsd:simpleType>
-/**
- * Renderer for simple section elements in documentation.
- *
- * @remarks
- * Handles various types of documentation sections including returns,
- * authors, notes, warnings, and custom sections. Maps section types
- * to appropriate HTML structures and Docusaurus admonitions.
- *
- * @public
- */
 export class DocSimpleSectTypeLinesRenderer extends ElementLinesRendererBase {
-    /**
-     * Renders a simple section element to formatted output lines.
-     *
-     * @remarks
-     * Converts Doxygen simple sections to HTML definition lists or
-     * Docusaurus admonitions based on section type. Supports standard
-     * sections like returns and notes, plus custom paragraph sections.
-     *
-     * @param element - The simple section element to render
-     * @param type - The rendering context type
-     * @returns Array of formatted output lines for the section
-     */
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         const lines = [];
-        // doxygen.git/src/translator_en.h
         const DoxSimpleSectKind = {
             see: 'See Also',
             return: 'Returns',
@@ -410,20 +186,13 @@ export class DocSimpleSectTypeLinesRenderer extends ElementLinesRendererBase {
             version: 'Version',
             since: 'Since',
             date: 'Date',
-            // note -> :::info (note is white in Docusaurus)
-            // warning -> :::warning
             pre: 'Precondition',
             post: 'Postcondition',
             copyright: 'Copyright',
             invariant: 'Invariant',
             remark: 'Remarks',
-            // attention: -> :::danger
-            // important: -> :::tip
-            // par: - paragraph with custom title
-            // rcs: - apparently ignored
         };
         lines.push('');
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (DoxSimpleSectKind[element.kind] !== undefined) {
             const { kind } = element;
             const title = DoxSimpleSectKind[kind];
@@ -471,24 +240,18 @@ export class DocSimpleSectTypeLinesRenderer extends ElementLinesRendererBase {
             lines.push('</dl>');
         }
         else if (element.kind === 'note') {
-            // https://docusaurus.io/docs/markdown-features/admonitions
             lines.push('');
             lines.push(':::info');
             lines.push(this.workspace
-                .renderElementToString(element.children, 
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            renderParagraphs ? 'html' : 'markdown')
+                .renderElementToString(element.children, renderParagraphs ? 'html' : 'markdown')
                 .trim());
             lines.push(':::');
         }
         else if (element.kind === 'warning') {
             lines.push('');
             lines.push(':::warning');
-            // console.log(util.inspect(element, { compact: false, depth: 999 }))
             lines.push(this.workspace
-                .renderElementToString(element.children, 
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            renderParagraphs ? 'html' : 'markdown')
+                .renderElementToString(element.children, renderParagraphs ? 'html' : 'markdown')
                 .trim());
             lines.push(':::');
         }
@@ -496,9 +259,7 @@ export class DocSimpleSectTypeLinesRenderer extends ElementLinesRendererBase {
             lines.push('');
             lines.push(':::danger');
             lines.push(this.workspace
-                .renderElementToString(element.children, 
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            renderParagraphs ? 'html' : 'markdown')
+                .renderElementToString(element.children, renderParagraphs ? 'html' : 'markdown')
                 .trim());
             lines.push(':::');
         }
@@ -506,9 +267,7 @@ export class DocSimpleSectTypeLinesRenderer extends ElementLinesRendererBase {
             lines.push('');
             lines.push(':::tip');
             lines.push(this.workspace
-                .renderElementToString(element.children, 
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            renderParagraphs ? 'html' : 'markdown')
+                .renderElementToString(element.children, renderParagraphs ? 'html' : 'markdown')
                 .trim());
             lines.push(':::');
         }
@@ -520,32 +279,8 @@ export class DocSimpleSectTypeLinesRenderer extends ElementLinesRendererBase {
         return lines;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for space elements in documentation.
- *
- * @remarks
- * Handles spacing elements that insert a specified number of space
- * characters into the output. Supports both single spaces and
- * multiple space sequences for formatting control.
- *
- * @public
- */
 export class SpTypeStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a space element to a string of space characters.
-     *
-     * @remarks
-     * Generates the specified number of space characters based on the
-     * element's value attribute. Defaults to a single space if no
-     * value is specified.
-     *
-     * @param element - The space element to render
-     * @param type - The rendering context type (unused in implementation)
-     * @returns String containing the specified number of spaces
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         let spaces = 1;
         if (element.value !== undefined && element.value.valueOf() > 1) {
@@ -557,32 +292,8 @@ export class SpTypeStringRenderer extends ElementStringRendererBase {
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for empty or structural elements in documentation.
- *
- * @remarks
- * Handles various empty elements that provide structural formatting
- * including horizontal rules, line breaks, and non-breakable spaces.
- * Maps element types to appropriate HTML equivalents.
- *
- * @public
- */
 export class DocEmptyTypeStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders an empty element to its HTML equivalent.
-     *
-     * @remarks
-     * Converts structural elements like horizontal rules and line breaks
-     * to their corresponding HTML tags. Provides error handling for
-     * unrecognised empty element types.
-     *
-     * @param element - The empty element to render
-     * @param type - The rendering context type (unused in implementation)
-     * @returns The formatted HTML string for the structural element
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         switch (element.constructor.name) {
             case 'HrulerDataModel':
@@ -604,32 +315,8 @@ export class DocEmptyTypeStringRenderer extends ElementStringRendererBase {
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for parameter list elements in documentation.
- *
- * @remarks
- * Handles complex parameter documentation including template parameters,
- * function parameters, return values, and exceptions. Generates structured
- * HTML tables for organised parameter presentation.
- *
- * @public
- */
 export class DocParamListTypeLinesRenderer extends ElementLinesRendererBase {
-    /**
-     * Renders a parameter list element to formatted output lines.
-     *
-     * @remarks
-     * Creates HTML definition lists and tables for parameter documentation.
-     * Processes parameter names, types, directions, and descriptions to
-     * generate comprehensive parameter documentation with proper formatting.
-     *
-     * @param element - The parameter list element to render
-     * @param type - The rendering context type
-     * @returns Array of HTML strings forming the parameter documentation
-     */
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         const lines = [];
         if (element.parameterItems !== undefined) {
             const titlesByKind = {
@@ -640,7 +327,6 @@ export class DocParamListTypeLinesRenderer extends ElementLinesRendererBase {
             };
             const { kind } = element;
             const title = titlesByKind[kind];
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             if (title === undefined) {
                 console.error(util.inspect(element, { compact: false, depth: 999 }));
                 console.error(element.constructor.name, 'kind', kind, 'not yet rendered in', this.constructor.name);
@@ -653,13 +339,9 @@ export class DocParamListTypeLinesRenderer extends ElementLinesRendererBase {
                     lines.push('<dd>');
                     lines.push('<table class="doxyParamsTable">');
                     for (const parameterItem of element.parameterItems) {
-                        // console.log(util.inspect(parameterItem,
-                        // { compact: false, depth: 999 }))
                         const names = [];
                         if (parameterItem.parameterNameList !== undefined) {
                             for (const parameterName of parameterItem.parameterNameList) {
-                                // console.log(util.inspect(parameterName.children,
-                                // { compact: false, depth: 999 }))
                                 assert(parameterName.children !== undefined);
                                 for (const child of parameterName.children) {
                                     assert(child instanceof AbstractDataModelBase);
@@ -718,180 +400,53 @@ export class DocParamListTypeLinesRenderer extends ElementLinesRendererBase {
         return lines;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for anchor elements in documentation.
- *
- * @remarks
- * Creates HTML anchor elements for cross-referencing within documents.
- * Generates sanitised anchor IDs that can be used for permalink
- * navigation and internal linking.
- *
- * @public
- */
 export class DocAnchorTypeLinesRenderer extends ElementLinesRendererBase {
-    /**
-     * Renders an anchor element to formatted output lines.
-     *
-     * @remarks
-     * Creates an HTML anchor element with a sanitised ID attribute
-     * for use in permalink generation and cross-referencing within
-     * the documentation.
-     *
-     * @param element - The anchor element to render
-     * @param type - The rendering context type (unused in implementation)
-     * @returns Array containing the HTML anchor element
-     */
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         const lines = [];
         const anchor = getPermalinkAnchor(element.id);
         lines.push(`<a id="${anchor}"></a>`);
         return lines;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for verbatim text elements in documentation.
- *
- * @remarks
- * Handles verbatim text blocks that should be displayed exactly as
- * written without interpretation. Generates HTML pre and code elements
- * with proper formatting for code snippets and literal text.
- *
- * @public
- */
 export class VerbatimStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a verbatim element to formatted HTML code block.
-     *
-     * @remarks
-     * Creates HTML pre and code elements for literal text display.
-     * Strips leading and trailing newlines while preserving internal
-     * formatting and enables copy functionality through Docusaurus.
-     *
-     * @param element - The verbatim element to render
-     * @param type - The rendering context type
-     * @returns The formatted HTML code block string
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         text += '\n';
-        // Docusaurus adds the copy button.
-        // The content must be on the same line.
         text += '\n';
         text += '<pre><code>';
         text += stripLeadingAndTrailingNewLines(this.workspace.renderElementsArrayToString(element.children, 'html'));
         text += '\n';
         text += '</code></pre>';
         text += '\n';
-        // text += '\n'
         return text;
     }
 }
-/**
- * Renderer for preformatted text elements in documentation.
- *
- * @remarks
- * Similar to verbatim rendering but specifically for preformatted content.
- * Maintains exact spacing and formatting while providing HTML code block
- * structure compatible with Docusaurus features.
- *
- * @public
- */
 export class PreformattedStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a preformatted element to formatted HTML code block.
-     *
-     * @remarks
-     * Creates HTML pre and code elements for preformatted text display.
-     * Preserves exact formatting while stripping unnecessary newlines
-     * and enabling Docusaurus copy button functionality.
-     *
-     * @param element - The preformatted element to render
-     * @param type - The rendering context type
-     * @returns The formatted HTML code block string
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         text += '\n';
-        // Docusaurus adds the copy button.
-        // The content must be on the same line.
         text += '\n';
         text += '<pre><code>';
         text += stripLeadingAndTrailingNewLines(this.workspace.renderElementsArrayToString(element.children, 'html'));
         text += '\n';
         text += '</code></pre>';
         text += '\n';
-        // text += '\n'
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for mathematical formula elements in documentation.
- *
- * @remarks
- * Handles LaTeX mathematical formulae by converting them to HTML code
- * elements. Provides warnings for limited formula rendering capabilities
- * and maintains formula content for basic display.
- *
- * @public
- */
 export class FormulaStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders a formula element to formatted HTML code.
-     *
-     * @remarks
-     * Converts LaTeX formulae to HTML code elements with basic formatting.
-     * Logs warnings about limited rendering capabilities and ignores
-     * formula IDs while preserving mathematical content.
-     *
-     * @param element - The formula element to render
-     * @param type - The rendering context type
-     * @returns The formatted HTML code string containing the formula
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         const formula = this.workspace.renderString(element.text, 'html');
         if (this.workspace.options.verbose) {
             console.warn('LaTeX formula', formula, 'not rendered properly');
         }
-        // element.id is ignored.
-        // Docusaurus renders it as a div with copy button.
         text += `<code>${formula}</code>`;
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for image elements in documentation.
- *
- * @remarks
- * Handles image rendering with support for various attributes including
- * dimensions, captions, and source URLs. Generates HTML figure elements
- * with proper image handling for both local and remote sources.
- *
- * @public
- */
 export class ImageStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders an image element to formatted HTML figure.
-     *
-     * @remarks
-     * Creates HTML figure and img elements with support for width, height,
-     * alt text, captions, and inline styling. Handles both URL and local
-     * image sources while skipping LaTeX-specific images.
-     *
-     * @param element - The image element to render
-     * @param type - The rendering context type (unused in implementation)
-     * @returns The formatted HTML figure string
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         if (element.type === 'html') {
             text += '\n';
@@ -942,7 +497,6 @@ export class ImageStringRenderer extends ElementStringRendererBase {
             text += '</figure>';
         }
         else if (element.type === 'latex') {
-            // Skipped, no LaTeX images rendered.
         }
         else {
             console.error('Image type', element.type, 'not rendered in', this.constructor.name);
@@ -950,63 +504,15 @@ export class ImageStringRenderer extends ElementStringRendererBase {
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for HTML-only content elements in documentation.
- *
- * @remarks
- * Handles content that should only appear in HTML output formats.
- * Processes HTML-specific markup while converting it to appropriate
- * text format for cross-platform compatibility.
- *
- * @public
- */
 export class HtmlOnlyStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders an HTML-only element to formatted text.
-     *
-     * @remarks
-     * Converts HTML-only content to plain text format for broader
-     * compatibility. Processes the element's text content through
-     * the workspace renderer with text formatting.
-     *
-     * @param element - The HTML-only element to render
-     * @param type - The rendering context type (unused in implementation)
-     * @returns The formatted text string
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
         text += this.workspace.renderString(element.text, 'text');
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for heading elements in documentation.
- *
- * @remarks
- * Converts Doxygen heading elements to Markdown heading syntax.
- * Supports multiple heading levels while providing warnings for
- * potentially problematic heading configurations.
- *
- * @public
- */
 export class HeadingLinesRenderer extends ElementLinesRendererBase {
-    /**
-     * Renders a heading element to formatted Markdown heading lines.
-     *
-     * @remarks
-     * Creates Markdown-style headings with appropriate hash symbols
-     * based on the heading level. Warns about level 1 headings that
-     * may interfere with Docusaurus page structure.
-     *
-     * @param element - The heading element to render
-     * @param type - The rendering context type
-     * @returns Array containing the formatted Markdown heading
-     */
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         const lines = [];
         if (element.level === 1) {
             if (this.workspace.options.verbose) {
@@ -1022,64 +528,15 @@ export class HeadingLinesRenderer extends ElementLinesRendererBase {
         return lines;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for emoji elements in documentation.
- *
- * @remarks
- * Handles Unicode emoji characters by wrapping them in appropriate
- * HTML span elements with CSS styling. Provides consistent emoji
- * display across different platforms and browsers.
- *
- * @public
- */
 export class EmojiStringRenderer extends ElementStringRendererBase {
-    /**
-     * Renders an emoji element to formatted HTML span.
-     *
-     * @remarks
-     * Creates an HTML span element with CSS class for emoji styling
-     * and includes the Unicode emoji character. Ensures consistent
-     * emoji presentation in documentation output.
-     *
-     * @param element - The emoji element to render
-     * @param type - The rendering context type (unused in implementation)
-     * @returns The formatted HTML span string with emoji
-     */
     renderToString(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         let text = '';
-        // <span class="emoji">&#x1f604;</span>
         text += `<span class="doxyEmoji">${element.unicode}</span>}`;
         return text;
     }
 }
-// ----------------------------------------------------------------------------
-/**
- * Renderer for blockquote elements in documentation.
- *
- * @remarks
- * Handles blockquote formatting by wrapping content in HTML blockquote
- * elements with appropriate CSS styling. Processes child elements to
- * maintain proper content structure within quotes.
- *
- * @public
- */
 export class BlockquoteLinesRenderer extends ElementLinesRendererBase {
-    /**
-     * Renders a blockquote element to formatted output lines.
-     *
-     * @remarks
-     * Creates HTML blockquote elements with CSS styling and processes
-     * child elements to generate properly formatted quoted content
-     * with appropriate indentation and styling.
-     *
-     * @param element - The blockquote element to render
-     * @param type - The rendering context type
-     * @returns Array of HTML strings forming the blockquote structure
-     */
     renderToLines(element, type) {
-        // console.log(util.inspect(element, { compact: false, depth: 999 }))
         const lines = [];
         lines.push('<blockquote class="doxyBlockQuote">');
         lines.push(...this.workspace.renderElementsArrayToLines(element.children, 'html'));
@@ -1087,5 +544,4 @@ export class BlockquoteLinesRenderer extends ElementLinesRendererBase {
         return lines;
     }
 }
-// ----------------------------------------------------------------------------
 //# sourceMappingURL=descriptiontype.js.map