@cometchat/chat-uikit-react 6.3.13 → 6.4.0

package/dist/types/components/CometChatLinkDialog/CometChatLinkDialog.d.ts

@@ -0,0 +1,22 @@
+interface LinkDialogProps {
+    /** The initial URL value */
+    initialUrl?: string;
+    /** The initial display text value */
+    initialText?: string;
+    /** Whether to show the text input field (hide when text is already selected) */
+    showTextInput?: boolean;
+    /** Whether this is edit mode (changes title and button text) */
+    isEditMode?: boolean;
+    /** When true, focus the Link field on mount instead of the Text field */
+    focusLinkField?: boolean;
+    /** Callback when the link is submitted */
+    onSubmit: (url: string, displayText?: string) => void;
+    /** Callback when the dialog is cancelled */
+    onCancel: () => void;
+}
+/**
+ * CometChatLinkDialog - A dialog for adding/editing hyperlinks
+ * Shows URL input and optional display text input
+ */
+export declare function CometChatLinkDialog(props: LinkDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/CometChatLinkPopover/CometChatLinkPopover.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+interface LinkPopoverProps {
+    /** The link text displayed */
+    linkText: string;
+    /** The URL of the link */
+    linkUrl: string;
+    /** Position of the popover */
+    position: {
+        top: number;
+        left: number;
+    };
+    /** Callback when Edit button is clicked */
+    onEdit: () => void;
+    /** Callback when Remove button is clicked */
+    onRemove: () => void;
+    /** Callback when popover should close */
+    onClose: () => void;
+}
+/**
+ * CometChatLinkPopover - A popover that appears when clicking on a link
+ * Shows link text, URL (clickable), and Edit/Remove buttons
+ */
+declare const CometChatLinkPopover: React.FC<LinkPopoverProps>;
+export { CometChatLinkPopover };

package/dist/types/components/CometChatLinkPopover/index.d.ts

@@ -0,0 +1 @@
+export { CometChatLinkPopover } from "./CometChatLinkPopover";

package/dist/types/components/useRichTextComposer/useRichTextComposer.d.ts

@@ -0,0 +1,138 @@
+import { FormatType } from "../../utils/RichTextFormatting";
+import { CometChatTextFormatter } from "../../formatters/CometChatFormatters/CometChatTextFormatter";
+/**
+ * Configuration for the useRichTextComposer hook
+ */
+export interface RichTextComposerConfig {
+    enableRichTextEditor: boolean;
+    hideRichTextFormattingOptions: boolean;
+    showToolbarOnSelection: boolean;
+    getCurrentDocument: () => Document;
+    getCurrentWindow: () => Window;
+    getCurrentInput: () => Element | null | undefined;
+    composerContainerClass: string;
+    errorHandler: (error: unknown, context: string) => void;
+    setTextFormatters: React.Dispatch<React.SetStateAction<CometChatTextFormatter[]>>;
+}
+export interface LinkPopoverData {
+    linkText: string;
+    linkUrl: string;
+    linkElement: HTMLAnchorElement | null;
+    position: {
+        top: number;
+        left: number;
+    };
+}
+export interface LinkEditData {
+    url: string;
+    text: string;
+}
+/**
+ * State for undoing markdown conversions
+ */
+export interface MarkdownUndoState {
+    originalHtml: string;
+    cursorPosition: number;
+    timestamp: number;
+}
+/**
+ * Shared hook that encapsulates all rich text formatting logic
+ * used by both CometChatMessageComposer and CometChatCompactMessageComposer.
+ */
+export declare function useRichTextComposer(config: RichTextComposerConfig): {
+    isFixedToolbarVisible: boolean;
+    setIsFixedToolbarVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isFloatingToolbarVisible: boolean;
+    setIsFloatingToolbarVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    floatingToolbarPosition: {
+        top: number;
+        left: number;
+    } | null;
+    activeFormats: FormatType[];
+    setActiveFormats: import("react").Dispatch<import("react").SetStateAction<FormatType[]>>;
+    showLinkInput: boolean;
+    showLinkPopover: boolean;
+    linkPopoverData: LinkPopoverData | null;
+    isLinkEditMode: boolean;
+    linkEditData: LinkEditData | null;
+    linkDialogSelectedText: string;
+    linkDialogSelectedTextRef: import("react").MutableRefObject<string>;
+    richTextFormatter: {
+        getSelection: () => Selection | null;
+        saveSelection: () => Range | null;
+        restoreSelection: (range: Range | null) => void;
+        hasSelection: () => boolean;
+        getSelectedText: (savedRange?: Range | null) => string;
+        isFormatted: (formatType: FormatType, containerElement: HTMLElement) => boolean;
+        isFormattingModeActive: () => boolean;
+        getActiveFormats: (containerElement: HTMLElement) => FormatType[];
+        getActiveFormattingModes: () => FormatType[];
+        findFormattingAncestor: () => HTMLElement | null;
+        applyFormat: () => void;
+        removeFormat: () => void;
+        toggleFormat: (formatType: FormatType, containerElement: HTMLElement) => void;
+        toggleFormattingMode: () => void;
+        toggleBold: (containerElement: HTMLElement) => void;
+        toggleItalic: (containerElement: HTMLElement) => void;
+        toggleUnderline: (containerElement: HTMLElement) => void;
+        toggleStrikethrough: (containerElement: HTMLElement) => void;
+        insertLink: (url: string, displayText: string | undefined, containerElement: HTMLElement) => void;
+        updateLink: (url: string, displayText: string | undefined, containerElement: HTMLElement) => void;
+        removeLink: (containerElement: HTMLElement) => void;
+        isInsideLink: (containerElement: HTMLElement) => boolean;
+        toggleOrderedList: (containerElement: HTMLElement) => void;
+        toggleUnorderedList: (containerElement: HTMLElement) => void;
+        fixOrderedListContinuation: (containerElement: HTMLElement) => void;
+        isInsideList: (listType: "orderedList" | "unorderedList", containerElement: HTMLElement) => HTMLElement | null;
+        isInsideAnyList: (containerElement: HTMLElement) => HTMLElement | null;
+        getCurrentListItem: (containerElement: HTMLElement) => HTMLLIElement | null;
+        isCurrentListItemEmpty: (containerElement: HTMLElement) => boolean;
+        isCursorAtListItemStart: (containerElement: HTMLElement) => boolean;
+        handleListBackspace: (containerElement: HTMLElement) => boolean;
+        handleListEnter: (containerElement: HTMLElement) => boolean;
+        handleListTab: (containerElement: HTMLElement, shiftKey: boolean) => boolean;
+        handleCodeBlockEnter: (containerElement: HTMLElement) => boolean;
+        handleCodeBlockBackspace: (containerElement: HTMLElement) => boolean;
+        handleAutoListTrigger: (containerElement: HTMLElement) => "orderedList" | "unorderedList" | null;
+        applyListInlineStyles: (containerElement: HTMLElement) => void;
+        toggleBlockquote: (containerElement: HTMLElement) => void;
+        isInsideBlockquote: (containerElement: HTMLElement) => HTMLElement | null;
+        toggleCodeInline: (containerElement: HTMLElement) => void;
+        toggleCodeBlock: (containerElement: HTMLElement) => void;
+        isInsideCodeInline: (containerElement: HTMLElement) => HTMLElement | null;
+        isInsideCodeBlock: (containerElement: HTMLElement) => HTMLElement | null;
+        handleInlineCodePreservation: (containerElement: HTMLElement, wasInsideInlineCode: boolean) => void;
+        clearFormattingModes: () => void;
+        resetFontContext: (containerElement?: HTMLElement) => void;
+        handleKeyboardShortcut: (event: KeyboardEvent, containerElement: HTMLElement) => boolean;
+        handleArrowKeyInCode: (event: KeyboardEvent, containerElement: HTMLElement) => boolean;
+        getPlainText: (htmlContent: string) => string;
+        normalizeHtml: (htmlContent: string) => string;
+        trimRichTextWhitespace: (html: string | null | undefined) => string;
+        handleMarkdownShortcuts: (containerElement: HTMLElement, onBeforeConversion?: () => void) => boolean;
+        clearPendingFormats: () => void;
+        getPendingFormats: () => FormatType[];
+        getTextOffsetAtCursor: (containerElement: HTMLElement) => number;
+        setCursorByTextOffset: (containerElement: HTMLElement, offset: number) => void;
+        convertMarkdownToFormat: (containerElement: HTMLElement, startOffset: number, endOffset: number, contentStart: number, contentEnd: number, formatType: FormatType, linkUrl?: string) => void;
+        positionCursorAfterFormat: (containerElement: HTMLElement, formattedNode: Node) => void;
+        applyMarkdownConversion: (containerElement: HTMLElement, match: {
+            startOffset: number;
+            endOffset: number;
+            contentStart: number;
+            contentEnd: number;
+            linkUrl?: string;
+        }, formatType: FormatType) => void;
+    } | null;
+    handleLinkClick: () => void;
+    handleLinkSubmit: (url: string, displayText?: string) => void;
+    handleLinkCancel: () => void;
+    handleInputClick: (event: React.MouseEvent) => void;
+    handleLinkPopoverEdit: () => void;
+    handleLinkPopoverRemove: () => void;
+    handleLinkPopoverClose: () => void;
+    handleFormatApplied: () => void;
+    handleFormattingKeyDown: (event: KeyboardEvent, contenteditable: Element) => boolean;
+    saveMarkdownUndoState: () => void;
+    handleMarkdownUndo: () => boolean;
+};

package/dist/types/formatters/CometChatFormatters/CometChatMarkdownFormatter/CometChatMarkdownFormatter.d.ts

@@ -0,0 +1,109 @@
+import { CometChatTextFormatter } from "../CometChatTextFormatter";
+import { MentionsTargetElement } from "../../../Enums/Enums";
+/**
+ * CometChatMarkdownFormatter
+ *
+ * Handles bidirectional conversion between HTML and markdown:
+ *
+ * BUBBLE SIDE (getFormattedText): Markdown → HTML for display
+ * - **bold** → <b>bold</b>
+ * - _italic_ → <i>italic</i>
+ * - <u>underline</u> → <u>underline</u> (pass-through)
+ * - ~~strikethrough~~ → <s>strikethrough</s>
+ * - `inline code` → <code>inline code</code>
+ * - ```code block``` → <pre><code>code block</code></pre>
+ * - > blockquote → <blockquote>blockquote</blockquote>
+ * - [text](url) → <a href="url">text</a>
+ *
+ * COMPOSER SIDE (getOriginalText): HTML → Markdown for storage
+ * - <b>bold</b> → **bold**
+ * - <i>italic</i> → _italic_
+ * - <u>underline</u> → <u>underline</u>
+ * - <s>strikethrough</s> → ~~strikethrough~~
+ * - <code>code</code> → `code`
+ * - <pre><code>code</code></pre> → ```code```
+ * - <blockquote>text</blockquote> → > text
+ * - <a href="url">text</a> → [text](url)
+ */
+export declare class CometChatMarkdownFormatter extends CometChatTextFormatter {
+    constructor();
+    /**
+     * BUBBLE SIDE: Convert markdown syntax to styled HTML for display
+     */
+    getFormattedText(inputText: string, params?: {
+        mentionsTargetElement?: MentionsTargetElement;
+    }): string;
+    /**
+     * COMPOSER SIDE: Pass through unchanged.
+     * HTML→Markdown conversion is handled exclusively by CometChatRichTextFormatter
+     * (via HtmlToMarkdown.ts). Running a second conversion here would double-process
+     * the text and corrupt mention spans before CometChatMentionsFormatter can replace
+     * them with <@uid:xxx> tokens.
+     */
+    getOriginalText(inputText: string | null | undefined): string;
+    /**
+     * Format code blocks: ```code``` → <pre><code>code</code></pre>
+     */
+    private formatCodeBlocks;
+    /**
+     * Apply a formatting function only to text segments outside of code blocks.
+     * Unlike formatOutsideCode, this does NOT split on inline <code> tags or mention placeholders.
+     * Used for blockquote processing which runs before inline code conversion.
+     */
+    private formatOutsideCodeBlocks;
+    /**
+     * Apply a formatting function only to text segments outside of code blocks and inline code.
+     * Splits the text by <pre><code>...</code></pre> and <code>...</code> segments,
+     * applies the formatter only to non-code parts, then reassembles.
+     */
+    private formatOutsideCode;
+    /**
+     * Format inline code: `code` → <code>code</code>
+     */
+    private formatInlineCode;
+    /**
+     * Format bold: **text** → <b>text</b>
+     */
+    private formatBold;
+    /**
+     * Format italic: _text_ → <i>text</i>
+     */
+    private formatItalic;
+    /**
+     * Format underline: <u>text</u> → <u>text</u>
+     * The markdown syntax uses HTML-style <u> tags directly.
+     * Also supports legacy ++text++ and __text__ for backward compatibility.
+     */
+    private formatUnderline;
+    /**
+     * Format strikethrough: ~~text~~ → <s>text</s>
+     */
+    private formatStrikethrough;
+    /**
+     * Format links: [text](url) → <a href="url">text</a>
+     */
+    private formatLinks;
+    /**
+     * Format blockquotes: > text → <blockquote>text</blockquote>
+     */
+    private formatBlockquotes;
+    /**
+     * Format ordered lists: 1. item → <li>item</li>
+     */
+    /**
+       * Format ordered lists: consecutive "N. item" lines → <ol><li>item</li></ol>
+       */
+    private formatOrderedLists;
+    /**
+     * Format unordered lists: • item or - item → <li>item</li>
+     */
+    /**
+       * Format unordered lists: consecutive "• item" or "- item" lines → <ul><li>item</li></ul>
+       */
+    private formatUnorderedLists;
+    /**
+     * Register click handlers for links
+     */
+    registerEventListeners(span: Element, classList: DOMTokenList): Element;
+    stripMarkdownForConversation(text: string): string;
+}

package/dist/types/formatters/CometChatFormatters/CometChatRichTextFormatter.d.ts

@@ -0,0 +1,32 @@
+import { CometChatTextFormatter } from "./CometChatTextFormatter";
+import { MentionsTargetElement } from "../../Enums/Enums";
+/**
+ * CometChatRichTextFormatter
+ *
+ * Handles rich text formatting for CometChat messages.
+ * - COMPOSER SIDE: Converts HTML from contenteditable to markdown for storage
+ * - BUBBLE SIDE: Passes through text as-is (markdown rendering handled by CometChatMarkdownFormatter)
+ */
+export declare class CometChatRichTextFormatter extends CometChatTextFormatter {
+    constructor();
+    /**
+     * BUBBLE SIDE: Pass through text as-is
+     * The CometChatMarkdownFormatter handles converting markdown to HTML for display
+     */
+    getFormattedText(inputText: string, _params?: {
+        mentionsTargetElement?: MentionsTargetElement;
+    }): string;
+    /**
+     * COMPOSER SIDE: Convert HTML from contenteditable to markdown
+     * This is called before sending the message to convert the rich HTML to markdown format
+     */
+    getOriginalText(inputText: string | null | undefined): string;
+    /**
+     * Check if the input contains HTML tags that need conversion
+     */
+    private containsHtmlTags;
+    /**
+     * Register click handlers for links in bubbles
+     */
+    registerEventListeners(span: Element, _classList: DOMTokenList): Element;
+}

package/dist/types/formatters/CometChatFormatters/CometChatUrlsFormatter/CometChatUrlsFormatter.d.ts

@@ -1,12 +1,18 @@
 import { CometChatTextFormatter } from "../CometChatTextFormatter";
 /**
  * Class that handles the text formatting for URLs in CometChat.
- * CometChatUrlsFormatter is a child class of CometChatTextFormatter.
- * It extends the functionality of text formatting to specifically handle URLs.
- * It is used in extension decorators like  link preview, message translation, and dataSource utils.
  */
 export declare class CometChatUrlsFormatter extends CometChatTextFormatter {
     constructor(regexPatterns: Array<RegExp>);
+    onKeyUp(event: KeyboardEvent): void;
+    /**
+     * DOM-based URL linkification for message bubbles.
+     * Walks ALL text nodes and wraps URLs in clickable spans.
+     * Never breaks HTML structure. URLs inside code blocks become clickable.
+     * Only skips text inside <a> tags.
+     */
     protected onRegexMatch(inputText?: string | null): string;
     registerEventListeners(element: HTMLElement, classList: DOMTokenList): HTMLElement;
+    formatComposerContent(_element: HTMLElement): void;
+    getOriginalText(inputText: string | null | undefined): string;
 }

package/dist/types/formatters/index.d.ts

@@ -2,3 +2,5 @@ export { CometChatTextFormatter } from './CometChatFormatters/CometChatTextForma
 export { CometChatUrlsFormatter } from './CometChatFormatters/CometChatUrlsFormatter/CometChatUrlsFormatter';
 export { CometChatMentionsFormatter } from './CometChatFormatters/CometChatMentionsFormatter/CometChatMentionsFormatter';
 export { CometChatTextHighlightFormatter } from './CometChatFormatters/CometChatTextHighlightFormatter/CometChatTextHighlightFormatter';
+export { CometChatRichTextFormatter } from './CometChatFormatters/CometChatRichTextFormatter';
+export { CometChatMarkdownFormatter } from './CometChatFormatters/CometChatMarkdownFormatter/CometChatMarkdownFormatter';

package/dist/types/index.d.ts

@@ -37,6 +37,7 @@ export { CometChatGroupMembers } from './components/CometChatGroupMembers/CometC
 export { CometChatGroups } from './components/CometChatGroups/CometChatGroups';
 export { CometChatMessageBubble } from './components/BaseComponents/CometChatMessageBubble/CometChatMessageBubble';
 export { CometChatMessageComposer } from './components/CometChatMessageComposer/CometChatMessageComposer';
+export { CometChatCompactMessageComposer } from './components/CometChatCompactMessageComposer/CometChatCompactMessageComposer';
 export { CometChatMessageHeader } from './components/CometChatMessageHeader/CometChatMessageHeader';
 export { CometChatMessageList } from './components/CometChatMessageList/CometChatMessageList';
 export { CometChatUsers } from './components/CometChatUsers/CometChatUsers';

package/dist/types/utils/EmojiShortcodeUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Replaces all unicode emoji characters in a string with their :shortcode: equivalents.
+ * Handles multi-codepoint emoji (ZWJ sequences, variation selectors, skin tones).
+ * Unknown emoji characters (not in emojis.ts) pass through unchanged.
+ */
+export declare function emojiToShortcode(text: string): string;
+/**
+ * Replaces all :shortcode: patterns in a string with their unicode emoji characters.
+ * Unknown shortcodes pass through unchanged.
+ */
+export declare function shortcodeToEmoji(text: string): string;

package/dist/types/utils/HtmlToMarkdown.d.ts

@@ -0,0 +1,52 @@
+/**
+ * HTML to Markdown Converter
+ *
+ * Converts rich text HTML from the message composer to markdown
+ * for storage and transmission.
+ *
+ * Conversion rules:
+ * - <b>, <strong> → **text**
+ * - <i>, <em> → _text_
+ * - <s>, <strike>, <del> → ~~text~~
+ * - <u> → <u>text</u> (HTML-style underline)
+ * - <code> (not in pre) → `text`
+ * - <pre><code> → ```text```
+ * - <blockquote> → > text
+ * - <a href="url">text</a> → [text](url)
+ * - <ol><li> → 1. text
+ * - <ul><li> → • text
+ */
+/**
+ * Convert HTML string to markdown
+ */
+export declare function htmlToMarkdown(html: string): string;
+/**
+ * Remove escape backslashes from markdown text before sending.
+ * Preserves literal markdown characters that were escaped by the user.
+ *
+ * Rules:
+ * - Single backslash before markdown character: remove backslash, keep character
+ * - Even number of backslashes: keep half of them (they escape each other)
+ * - Odd number of backslashes: keep (n-1)/2 backslashes, last one escapes the markdown char
+ *
+ * Examples:
+ * - \* → *
+ * - \\* → \*
+ * - \\\* → \*
+ * - \\\\* → \\*
+ *
+ * @param text - Markdown text that may contain escape sequences
+ * @returns Text with escape backslashes removed
+ */
+export declare function removeEscapeBackslashes(text: string): string;
+/**
+ * Clean up markdown output
+ * - Remove excessive newlines
+ * - Trim whitespace
+ */
+export declare function cleanMarkdown(markdown: string): string;
+/**
+ * Convert HTML to clean markdown
+ * Removes escape backslashes before sending (Requirement 12.2)
+ */
+export declare function convertHtmlToMarkdown(html: string): string;

package/dist/types/utils/MarkdownPatternDetector.d.ts

@@ -0,0 +1,108 @@
+/**
+ * MarkdownPatternDetector - Utility for detecting and validating markdown syntax patterns
+ * in contenteditable elements for automatic conversion to rich text formatting.
+ */
+/**
+ * Represents a markdown pattern definition
+ */
+export interface MarkdownPattern {
+    type: 'bold' | 'italic' | 'underline' | 'strikethrough' | 'codeInline' | 'codeBlock' | 'link';
+    openDelimiter: string;
+    closeDelimiter: string;
+    priority: number;
+    /** If true, use custom detection logic instead of standard delimiter matching */
+    customDetection?: boolean;
+}
+/**
+ * Represents a detected markdown pattern match
+ */
+export interface PatternMatch {
+    pattern: MarkdownPattern;
+    startOffset: number;
+    endOffset: number;
+    contentStart: number;
+    contentEnd: number;
+    content: string;
+    linkUrl?: string;
+}
+/**
+ * Context information for pattern detection
+ */
+export interface DetectionContext {
+    text: string;
+    cursorOffset: number;
+    triggerChar: string;
+    scopeStart: number;
+    scopeEnd: number;
+}
+/**
+ * Supported markdown patterns ordered by priority (highest first)
+ */
+export declare const MARKDOWN_PATTERNS: MarkdownPattern[];
+/**
+ * Map of trigger characters to their associated patterns for efficient lookup
+ */
+export declare const TRIGGER_CHARS: Record<string, MarkdownPattern[]>;
+/**
+ * Detects markdown patterns in text at cursor position
+ *
+ * @param context - Detection context with text, cursor position, and scope boundaries
+ * @returns PatternMatch if valid pattern found, null otherwise
+ */
+export declare function detectMarkdownPattern(context: DetectionContext): PatternMatch | null;
+/**
+ * Validates that a pattern match is properly formed
+ *
+ * @param match - Pattern match to validate
+ * @param context - Detection context
+ * @returns true if pattern is valid, false otherwise
+ */
+export declare function validatePattern(match: PatternMatch, context: DetectionContext): boolean;
+/**
+ * Checks if a position in text is within an escape sequence
+ *
+ * @param text - Full text content
+ * @param position - Position to check
+ * @returns true if position is escaped, false otherwise
+ */
+export declare function isEscaped(text: string, position: number): boolean;
+/**
+ * Finds scope boundaries (paragraph/block element) for pattern matching
+ *
+ * @param element - Container element
+ * @param cursorNode - Current cursor node
+ * @param cursorOffset - Current cursor offset
+ * @returns Object with start and end offsets of the scope
+ */
+export declare function findScopeBoundaries(element: HTMLElement, cursorNode: Node, cursorOffset: number): {
+    start: number;
+    end: number;
+};
+/**
+ * Checks if the cursor is currently inside a mention element.
+ * Mention elements use `<span class="cometchat-mentions">`.
+ *
+ * @param cursorNode - The DOM node where the cursor is positioned
+ * @param containerElement - The contenteditable container element
+ * @returns true if cursor is inside a mention span, false otherwise
+ */
+export declare function isCursorInsideMention(cursorNode: Node, containerElement: HTMLElement): boolean;
+/**
+ * Checks if the cursor is currently inside a link (anchor) element.
+ *
+ * @param cursorNode - The DOM node where the cursor is positioned
+ * @param containerElement - The contenteditable container element
+ * @returns true if cursor is inside an <a> element, false otherwise
+ */
+export declare function isCursorInsideLink(cursorNode: Node, containerElement: HTMLElement): boolean;
+/**
+ * Checks if a pattern match spans across a mention or link element boundary.
+ * This prevents markdown patterns from being matched when the opening delimiter
+ * is outside a mention/link and the closing delimiter is inside (or vice versa).
+ *
+ * @param containerElement - The contenteditable container element
+ * @param startOffset - Text offset of the pattern start (opening delimiter)
+ * @param endOffset - Text offset of the pattern end (closing delimiter)
+ * @returns true if the pattern crosses a mention or link boundary, false otherwise
+ */
+export declare function patternCrossesMentionOrLink(containerElement: HTMLElement, startOffset: number, endOffset: number): boolean;