@ansonlai/docx-redline-js 0.1.0

package/services/browser-demo-prompt-context.js

@@ -0,0 +1,345 @@
+/**
+ * Builds prompt sections for browser-demo paragraph context.
+ *
+ * Plain lines are always emitted as `[P#] ...`.
+ * Formatting lines are emitted as `[P#_FMT] ...` only when markdown projection
+ * differs from plain text.
+ *
+ * @param {Array<{ index?: number, text?: string, formattedText?: string }>} paragraphs
+ * @returns {{ plainListing: string, formattingListing: string }}
+ */
+export function buildPromptParagraphSections(paragraphs) {
+    const items = Array.isArray(paragraphs) ? paragraphs : [];
+    const plainLines = [];
+    const formattingLines = [];
+
+    for (let i = 0; i < items.length; i += 1) {
+        const paragraph = items[i] || {};
+        const index = Number.isInteger(paragraph.index) && paragraph.index > 0 ? paragraph.index : (i + 1);
+        const text = String(paragraph.text || '').trim();
+        if (!text) continue;
+
+        const formattedText = String(paragraph.formattedText || text).trim() || text;
+        plainLines.push(`[P${index}] ${text}`);
+        if (formattedText !== text) {
+            formattingLines.push(`[P${index}_FMT] ${formattedText}`);
+        }
+    }
+
+    return {
+        plainListing: plainLines.join('\n'),
+        formattingListing: formattingLines.join('\n')
+    };
+}
+
+function normalizeWhitespace(value) {
+    return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function truncateForLog(value, maxChars = 140) {
+    const text = normalizeWhitespace(value);
+    if (text.length <= maxChars) return text;
+    return `${text.slice(0, maxChars - 1)}…`;
+}
+
+function extractQueryPhrases(userMessage) {
+    const message = String(userMessage || '');
+    const queries = [];
+    const seen = new Set();
+    const addQuery = (raw) => {
+        const normalized = normalizeWhitespace(raw);
+        if (!normalized || normalized.length < 2) return;
+        const key = normalized.toLowerCase();
+        if (seen.has(key)) return;
+        seen.add(key);
+        queries.push(normalized);
+    };
+
+    const quotedRegex = /"([^"]+)"|'([^']+)'/g;
+    let quotedMatch = quotedRegex.exec(message);
+    while (quotedMatch) {
+        addQuery(quotedMatch[1] || quotedMatch[2]);
+        quotedMatch = quotedRegex.exec(message);
+    }
+
+    const capitalizedPhraseRegex = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b/g;
+    let capMatch = capitalizedPhraseRegex.exec(message);
+    while (capMatch) {
+        addQuery(capMatch[1]);
+        capMatch = capitalizedPhraseRegex.exec(message);
+    }
+
+    return queries.slice(0, 8);
+}
+
+function extractQuotedPhrases(text) {
+    const message = String(text || '');
+    const phrases = [];
+    const seen = new Set();
+    const add = (raw) => {
+        const normalized = normalizeWhitespace(raw);
+        if (!normalized || normalized.length < 2) return;
+        const key = normalized.toLowerCase();
+        if (seen.has(key)) return;
+        seen.add(key);
+        phrases.push(normalized);
+    };
+
+    const regexes = [
+        /"([^"]+)"/g,
+        /'([^']+)'/g,
+        /“([^”]+)”/g,
+        /‘([^’]+)’/g
+    ];
+    for (const pattern of regexes) {
+        let match = pattern.exec(message);
+        while (match) {
+            add(match[1]);
+            match = pattern.exec(message);
+        }
+    }
+
+    return phrases;
+}
+
+const MESSAGE_STOP_WORDS = new Set([
+    'a', 'an', 'and', 'as', 'at', 'be', 'by', 'for', 'from', 'in', 'into', 'is', 'it', 'of', 'on', 'or', 'the',
+    'to', 'with', 'please', 'can', 'could', 'would', 'should', 'this', 'that', 'there', 'here',
+    'section', 'paragraph', 'clause', 'line',
+    'bold', 'unbold', 'rebold', 'remove', 'make', 'set', 'change', 'format', 'formatting', 'text'
+]);
+
+function inferQueriesFromParagraphCorpus(paragraphs, userMessage, maxQueries = 8) {
+    const corpus = [];
+    for (const paragraph of paragraphs || []) {
+        const plain = normalizeWhitespace(paragraph?.text).toLowerCase();
+        const formatted = normalizeWhitespace(paragraph?.formattedText || paragraph?.text).toLowerCase();
+        if (plain) corpus.push(plain);
+        if (formatted && formatted !== plain) corpus.push(formatted);
+    }
+    if (corpus.length === 0) return [];
+
+    const messageTokens = (String(userMessage || '').toLowerCase().match(/[a-z0-9']+/g) || [])
+        .filter(token => token.length > 1)
+        .filter(token => !MESSAGE_STOP_WORDS.has(token));
+    if (messageTokens.length === 0) return [];
+
+    const candidates = [];
+    const seen = new Set();
+    const maxN = Math.min(5, messageTokens.length);
+    for (let size = maxN; size >= 2; size -= 1) {
+        for (let i = 0; i <= messageTokens.length - size; i += 1) {
+            const phrase = messageTokens.slice(i, i + size).join(' ');
+            if (seen.has(phrase)) continue;
+            seen.add(phrase);
+            if (corpus.some(line => line.includes(phrase))) {
+                candidates.push(phrase);
+                if (candidates.length >= maxQueries) return candidates;
+            }
+        }
+    }
+
+    if (candidates.length > 0) return candidates;
+
+    // Last resort: allow single-token phrase when it is distinctive and present.
+    for (const token of messageTokens) {
+        if (seen.has(token)) continue;
+        seen.add(token);
+        if (corpus.some(line => line.includes(token))) {
+            candidates.push(token);
+            if (candidates.length >= maxQueries) break;
+        }
+    }
+
+    return candidates;
+}
+
+/**
+ * Builds turn-level diagnostics for formatting-aware targeting.
+ *
+ * Uses quoted phrases and capitalized phrases from the user message to find
+ * paragraphs where plain/formatting snapshots match.
+ *
+ * @param {Array<{ index?: number, text?: string, formattedText?: string }>} paragraphs
+ * @param {string} userMessage
+ * @param {{ maxMatches?: number }} [options]
+ * @returns {{
+ *   queries: string[],
+ *   matches: Array<{ query: string, index: number, differs: boolean, text: string, formattedText: string }>,
+ *   logLines: string[]
+ * }}
+ */
+export function buildFormattingDiagnostics(paragraphs, userMessage, options = {}) {
+    const maxMatches = Number.isInteger(options?.maxMatches) && options.maxMatches > 0
+        ? options.maxMatches
+        : 12;
+    const items = Array.isArray(paragraphs) ? paragraphs : [];
+    const queries = extractQueryPhrases(userMessage);
+    if (queries.length === 0) {
+        queries.push(...inferQueriesFromParagraphCorpus(items, userMessage, 8));
+    }
+    const matches = [];
+    const logLines = [];
+
+    if (queries.length === 0) {
+        return {
+            queries,
+            matches,
+            logLines: ['No candidate quoted/capitalized query phrases detected in user message.']
+        };
+    }
+
+    for (const query of queries) {
+        const queryLower = query.toLowerCase();
+        for (let i = 0; i < items.length; i += 1) {
+            if (matches.length >= maxMatches) break;
+            const paragraph = items[i] || {};
+            const index = Number.isInteger(paragraph.index) && paragraph.index > 0 ? paragraph.index : (i + 1);
+            const text = normalizeWhitespace(paragraph.text);
+            if (!text) continue;
+            const formattedText = normalizeWhitespace(paragraph.formattedText || text) || text;
+            const plainHas = text.toLowerCase().includes(queryLower);
+            const formattedHas = formattedText.toLowerCase().includes(queryLower);
+            if (!plainHas && !formattedHas) continue;
+
+            const differs = formattedText !== text;
+            matches.push({ query, index, differs, text, formattedText });
+        }
+        if (matches.length >= maxMatches) break;
+    }
+
+    if (matches.length === 0) {
+        logLines.push(`No paragraph matches found for queries: ${queries.map(q => `"${q}"`).join(', ')}`);
+        return { queries, matches, logLines };
+    }
+
+    for (const match of matches) {
+        logLines.push(
+            `Query "${match.query}" -> P${match.index} differs=${match.differs}; `
+            + `plain="${truncateForLog(match.text)}"; formatted="${truncateForLog(match.formattedText)}"`
+        );
+    }
+    if (matches.length >= maxMatches) {
+        logLines.push(`Match output truncated at ${maxMatches} entries.`);
+    }
+
+    return { queries, matches, logLines };
+}
+
+/**
+ * Detects whether a user message is requesting formatting removal/unformat.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function isFormattingRemovalIntent(text) {
+    const input = String(text || '').toLowerCase();
+    if (!input.trim()) return false;
+    return /(unbold|unitalic|ununderline|clear formatting|remove formatting|remove .*format|remove .*style|plain text|de-?bold|strip formatting)/i.test(input)
+        || (/\bremove\b/i.test(input) && /\b(bold|italic|underline|highlight|format|formatting|style)\b/i.test(input));
+}
+
+function rankFallbackCandidate(candidate) {
+    let score = 0;
+    if (candidate.differs) score += 1000;
+    if (candidate.source === 'assistant_quote') score += 120;
+    if (candidate.source === 'user_quote') score += 100;
+    if (candidate.source === 'user_query') score += 80;
+    score += Math.min(40, String(candidate.phrase || '').length);
+    return score;
+}
+
+/**
+ * Builds a deterministic fallback redline candidate for formatting-removal
+ * turns when the model returns zero operations.
+ *
+ * The candidate uses unchanged plain paragraph text as `modified`, which
+ * triggers format-removal behavior in the reconciliation engine.
+ *
+ * @param {Array<{ index?: number, text?: string, formattedText?: string }>} paragraphs
+ * @param {string} userMessage
+ * @param {string} [assistantExplanation]
+ * @returns {{ type: 'redline', targetRef: number, target: string, modified: string }|null}
+ */
+export function buildFormattingRemovalFallbackCandidate(paragraphs, userMessage, assistantExplanation = '') {
+    const items = Array.isArray(paragraphs) ? paragraphs : [];
+    if (items.length === 0) return null;
+
+    const diagnostics = buildFormattingDiagnostics(items, userMessage);
+    const phraseSources = [];
+    const seen = new Set();
+    const pushPhrase = (phrase, source) => {
+        const normalized = normalizeWhitespace(phrase);
+        if (!normalized) return;
+        const key = normalized.toLowerCase();
+        if (seen.has(`${source}:${key}`)) return;
+        seen.add(`${source}:${key}`);
+        phraseSources.push({ phrase: normalized, source });
+    };
+
+    for (const query of diagnostics.queries || []) pushPhrase(query, 'user_query');
+    for (const phrase of extractQuotedPhrases(userMessage)) pushPhrase(phrase, 'user_quote');
+    for (const phrase of extractQuotedPhrases(assistantExplanation)) pushPhrase(phrase, 'assistant_quote');
+
+    const candidates = [];
+    for (const sourceEntry of phraseSources) {
+        const phraseLower = sourceEntry.phrase.toLowerCase();
+        for (let i = 0; i < items.length; i += 1) {
+            const paragraph = items[i] || {};
+            const index = Number.isInteger(paragraph.index) && paragraph.index > 0 ? paragraph.index : (i + 1);
+            const text = normalizeWhitespace(paragraph.text);
+            if (!text) continue;
+            const formattedText = normalizeWhitespace(paragraph.formattedText || text) || text;
+            const plainHas = text.toLowerCase().includes(phraseLower);
+            const formattedHas = formattedText.toLowerCase().includes(phraseLower);
+            if (!plainHas && !formattedHas) continue;
+            const differs = formattedText !== text;
+            if (!differs) continue;
+
+            candidates.push({
+                phrase: sourceEntry.phrase,
+                source: sourceEntry.source,
+                index,
+                text,
+                modified: text,
+                differs
+            });
+        }
+    }
+
+    if (candidates.length === 0 && Array.isArray(diagnostics.matches) && diagnostics.matches.length > 0) {
+        for (const anchor of diagnostics.matches) {
+            const anchorIndex = Number.parseInt(anchor.index, 10);
+            if (!Number.isInteger(anchorIndex) || anchorIndex < 1) continue;
+            const nearbyIndexes = [anchorIndex + 1, anchorIndex - 1, anchorIndex + 2, anchorIndex - 2];
+            for (const idx of nearbyIndexes) {
+                const paragraph = items.find(item => Number(item?.index) === idx);
+                if (!paragraph) continue;
+                const text = normalizeWhitespace(paragraph.text);
+                if (!text) continue;
+                const formattedText = normalizeWhitespace(paragraph.formattedText || text) || text;
+                const differs = formattedText !== text;
+                if (!differs) continue;
+
+                candidates.push({
+                    phrase: `nearby:P${anchorIndex}`,
+                    source: 'section_proximity',
+                    index: idx,
+                    text,
+                    modified: text,
+                    differs
+                });
+            }
+        }
+    }
+
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => rankFallbackCandidate(b) - rankFallbackCandidate(a));
+    const best = candidates[0];
+    return {
+        type: 'redline',
+        targetRef: best.index,
+        target: best.text,
+        modified: best.modified
+    };
+}

package/services/comment-builders.js

@@ -0,0 +1,60 @@
+/**
+ * Comment XML builders.
+ */
+
+import { NS_W, escapeXml } from '../core/types.js';
+
+/**
+ * Builds a single w:comment element.
+ *
+ * @param {number} commentId - Unique comment ID
+ * @param {string} author - Author name
+ * @param {string} content - Comment text content
+ * @param {string} date - ISO date string
+ * @returns {string}
+ */
+export function buildCommentElement(commentId, author, content, date) {
+    const initials = author.split(' ').map(word => word[0]).join('').toUpperCase() || 'AI';
+    const escapedContent = escapeXml(content);
+    const escapedAuthor = escapeXml(author);
+
+    return `<w:comment w:id="${commentId}" w:author="${escapedAuthor}" w:date="${date}" w:initials="${initials}">
+      <w:p>
+        <w:r><w:t>${escapedContent}</w:t></w:r>
+      </w:p>
+    </w:comment>`;
+}
+
+/**
+ * Builds the complete comments.xml part.
+ *
+ * @param {Array<{id:number,content:string,author:string,date:string}>} comments - Placed comments
+ * @returns {string}
+ */
+export function buildCommentsPartXml(comments) {
+    if (!comments || comments.length === 0) {
+        return `<w:comments xmlns:w="${NS_W}"></w:comments>`;
+    }
+
+    const commentElements = comments.map(comment =>
+        buildCommentElement(comment.id, comment.author, comment.content, comment.date)
+    ).join('\n    ');
+
+    return `<w:comments xmlns:w="${NS_W}">
+    ${commentElements}
+  </w:comments>`;
+}
+
+/**
+ * Builds inline range/reference markers for a comment id.
+ *
+ * @param {number} commentId - The comment ID
+ * @returns {{ start: string, end: string, reference: string }}
+ */
+export function buildCommentMarkers(commentId) {
+    return {
+        start: `<w:commentRangeStart w:id="${commentId}"/>`,
+        end: `<w:commentRangeEnd w:id="${commentId}"/>`,
+        reference: `<w:r><w:rPr></w:rPr><w:commentReference w:id="${commentId}"/></w:r>`
+    };
+}

package/services/comment-engine.js

@@ -0,0 +1,248 @@
+/**
+ * OOXML Comment Engine
+ *
+ * Provides pure OOXML-based comment insertion without Word JS API calls.
+ */
+
+import { NS_W, getNextRevisionId, getRevisionTimestamp, resetRevisionIdCounter } from '../core/types.js';
+import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { log, error as logError } from '../adapters/logger.js';
+import { getElementsByTag, getFirstElementByTag, getXmlParseError } from '../core/xml-query.js';
+import { buildCommentElement, buildCommentsPartXml, buildCommentMarkers } from './comment-builders.js';
+import { getDefaultAuthor } from '../adapters/config.js';
+import { createParagraphTextIndex, injectMarkersIntoParagraph } from './comment-locator.js';
+import {
+    injectCommentsIntoPackage as injectCommentsIntoExistingPackage,
+    wrapParagraphWithComments,
+    wrapWithCommentsPart
+} from './comment-package.js';
+
+export { getNextRevisionId, resetRevisionIdCounter };
+export { buildCommentElement, buildCommentsPartXml, buildCommentMarkers };
+
+/**
+ * @typedef {Object} CommentRequest
+ * @property {number} paragraphIndex - 1-based paragraph index
+ * @property {string} textToFind - Text to attach comment to
+ * @property {string} commentContent - The comment text
+ */
+
+/**
+ * @typedef {Object} CommentInjectionResult
+ * @property {string} oxml - Complete OOXML package with comments
+ * @property {string} [commentsXml] - comments.xml content when comments are applied
+ * @property {number} commentsApplied - Number of successfully placed comments
+ * @property {string[]} warnings - Any issues encountered
+ */
+
+function parseDocumentOxml(oxml, parser, parseFailureWarning) {
+    try {
+        const xmlDoc = parser.parseFromString(oxml, 'text/xml');
+        const parseError = getXmlParseError(xmlDoc);
+        if (parseError) {
+            return { xmlDoc: null, warning: parseFailureWarning(parseError.textContent || 'parse error') };
+        }
+        return { xmlDoc, warning: null };
+    } catch (error) {
+        return { xmlDoc: null, warning: parseFailureWarning(error.message) };
+    }
+}
+
+/**
+ * Injects comments into OOXML using pure XML manipulation.
+ *
+ * @param {string} oxml - Original document OOXML
+ * @param {CommentRequest[]} comments - Comment requests
+ * @param {Object} [options={}] - Options
+ * @param {string} [options.author] - Author for comments (defaults to configured default author)
+ * @returns {CommentInjectionResult}
+ */
+export function injectCommentsIntoOoxml(oxml, comments, options = {}) {
+    const author = options?.author || getDefaultAuthor();
+    const date = getRevisionTimestamp();
+    const warnings = [];
+    const placedComments = [];
+
+    if (!comments || comments.length === 0) {
+        return {
+            oxml,
+            commentsApplied: 0,
+            warnings: ['No comments to inject']
+        };
+    }
+
+    const parser = createParser();
+    const serializer = createSerializer();
+    const parseResult = parseDocumentOxml(
+        oxml,
+        parser,
+        warning => `Failed to parse OXML: ${warning}`
+    );
+
+    if (!parseResult.xmlDoc) {
+        logError('[CommentEngine] Parse failure:', parseResult.warning);
+        return {
+            oxml,
+            commentsApplied: 0,
+            warnings: [parseResult.warning]
+        };
+    }
+
+    const xmlDoc = parseResult.xmlDoc;
+    const paragraphs = getElementsByTag(xmlDoc, 'w:p');
+    log(`[CommentEngine] Found ${paragraphs.length} paragraphs, processing ${comments.length} comment requests`);
+
+    /** @type {Map<number, number>} */
+    const remainingRequestsByParagraph = new Map();
+    for (const request of comments) {
+        const paragraphIndex = request.paragraphIndex - 1;
+        if (paragraphIndex < 0 || paragraphIndex >= paragraphs.length) {
+            warnings.push(`Paragraph ${request.paragraphIndex} out of range (1-${paragraphs.length})`);
+            continue;
+        }
+        remainingRequestsByParagraph.set(paragraphIndex, (remainingRequestsByParagraph.get(paragraphIndex) || 0) + 1);
+    }
+
+    /** @type {Map<number, { fullText: string, runOffsets: Array<{run: Element, start: number, end: number}> }>} */
+    const paragraphIndexes = new Map();
+
+    for (const request of comments) {
+        const paragraphIndex = request.paragraphIndex - 1;
+        if (paragraphIndex < 0 || paragraphIndex >= paragraphs.length) {
+            continue;
+        }
+
+        const targetParagraph = paragraphs[paragraphIndex];
+        let textIndex = paragraphIndexes.get(paragraphIndex);
+        if (!textIndex) {
+            textIndex = createParagraphTextIndex(targetParagraph);
+            paragraphIndexes.set(paragraphIndex, textIndex);
+        }
+
+        const commentId = getNextRevisionId();
+        const success = injectMarkersIntoParagraph(
+            xmlDoc,
+            targetParagraph,
+            request.textToFind,
+            commentId,
+            textIndex
+        );
+
+        const remaining = (remainingRequestsByParagraph.get(paragraphIndex) || 1) - 1;
+        remainingRequestsByParagraph.set(paragraphIndex, remaining);
+
+        if (!success) {
+            warnings.push(`Could not find "${request.textToFind.substring(0, 30)}..." in paragraph ${request.paragraphIndex}`);
+            if (remaining === 0) {
+                paragraphIndexes.delete(paragraphIndex);
+            }
+            continue;
+        }
+
+        placedComments.push({
+            id: commentId,
+            content: request.commentContent,
+            author,
+            date
+        });
+
+        if (remaining > 0) {
+            // Rebuild only when another request still targets this paragraph.
+            paragraphIndexes.set(paragraphIndex, createParagraphTextIndex(targetParagraph));
+        } else {
+            paragraphIndexes.delete(paragraphIndex);
+        }
+    }
+
+    if (placedComments.length === 0) {
+        return {
+            oxml,
+            commentsApplied: 0,
+            warnings
+        };
+    }
+
+    return {
+        oxml: serializer.serializeToString(xmlDoc),
+        commentsXml: buildCommentsPartXml(placedComments),
+        commentsApplied: placedComments.length,
+        warnings
+    };
+}
+
+/**
+ * Injects a comment into a single paragraph OOXML and returns a complete mini-package.
+ *
+ * @param {string} paragraphOoxml - Paragraph OOXML (raw paragraph or pkg:package)
+ * @param {string} textToFind - Target text
+ * @param {string} commentContent - Comment body
+ * @param {Object} [options={}] - Options
+ * @param {string} [options.author='AI Assistant'] - Comment author
+ * @returns {{ success: boolean, package?: string, warning?: string, commentId?: number }}
+ */
+export function injectCommentIntoParagraphOoxml(paragraphOoxml, textToFind, commentContent, options = {}) {
+    const { author = 'AI Assistant' } = options;
+    const date = getRevisionTimestamp();
+    const commentId = getNextRevisionId();
+
+    const parser = createParser();
+    const serializer = createSerializer();
+    const parseResult = parseDocumentOxml(
+        paragraphOoxml,
+        parser,
+        warning => `Failed to parse paragraph OOXML: ${warning}`
+    );
+
+    if (!parseResult.xmlDoc) {
+        return { success: false, warning: parseResult.warning };
+    }
+
+    const xmlDoc = parseResult.xmlDoc;
+    const paragraphs = getElementsByTag(xmlDoc, 'w:p');
+    if (paragraphs.length === 0) {
+        return { success: false, warning: 'No paragraph found in OOXML' };
+    }
+
+    const paragraph = paragraphs[0];
+    const paragraphIndex = createParagraphTextIndex(paragraph);
+    const success = injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, paragraphIndex);
+    if (!success) {
+        return { success: false, warning: `Could not find "${textToFind.substring(0, 30)}..." in paragraph` };
+    }
+
+    const commentElement = buildCommentElement(commentId, author, commentContent, date);
+    const commentsXml = `<w:comments xmlns:w="${NS_W}">${commentElement}</w:comments>`;
+    const pkgPackage = getFirstElementByTag(xmlDoc, 'pkg:package');
+
+    if (pkgPackage) {
+        const withComments = injectCommentsIntoExistingPackage(serializer.serializeToString(xmlDoc), commentsXml);
+        return { success: true, package: withComments, commentId };
+    }
+
+    const modifiedParagraphXml = serializer.serializeToString(xmlDoc);
+    return {
+        success: true,
+        package: wrapParagraphWithComments(modifiedParagraphXml, commentsXml),
+        commentId
+    };
+}
+
+/**
+ * Injects comments part into an existing OOXML package from getOoxml().
+ *
+ * @param {string} packageOxml - Existing pkg:package
+ * @param {string} commentsXml - comments.xml payload
+ * @returns {string}
+ */
+export function injectCommentsIntoPackage(packageOxml, commentsXml) {
+    return injectCommentsIntoExistingPackage(packageOxml, commentsXml);
+}
+
+/**
+ * @deprecated Use injectCommentsIntoPackage instead.
+ *
+ * @param {string} documentXml - Document XML
+ * @param {string} commentsXml - comments.xml payload
+ * @returns {string}
+ */
+export { wrapWithCommentsPart };