roosterjs 9.53.0 → 9.54.0

package/dist/rooster-amd.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for roosterjs (Version 9.53.0)
+// Type definitions for roosterjs (Version 9.54.0)
 // Generated by dts tool from roosterjs
 // Project: https://github.com/Microsoft/roosterjs
 
@@ -1511,7 +1511,11 @@ export type PasteType = /**
 /**
  * If there is a image uri in the clipboard, paste the content as image element
  */
- | 'asImage';
+ | 'asImage'
+/**
+ * If the editor includes a markdown plugin @see MarkdownPastePlugin, and there is markdown content in the clipboard, paste it as markdown
+ */
+ | 'asMarkdown';
 
 /**
  * All Border operations
@@ -2883,6 +2887,13 @@ export interface DomToModelSettings {
      * If true elements that has display:none style will be processed
      */
     processNonVisibleElements?: boolean;
+    /**
+     * When set to true, if a container element could be represented by a FormatContainer, always keep the
+     * FormatContainer and never fall back to a paragraph, even when it only has a single child.
+     * Set this when the intermediate FormatContainer is persisted during DOM to Content Model conversion
+     * and is later used during formatting.
+     */
+    skipFormatContainerFallbackCheck?: boolean;
 }
 
 /**
@@ -3303,6 +3314,13 @@ export interface DomToModelOptionForCreateModel extends DomToModelOption  {
      * When this option is passed, "tryGetFromCache" will be ignored.
      */
     recalculateTableSize?: boolean | 'all' | 'selected' | 'none';
+    /**
+     * When set to true, if a container element could be represented by a FormatContainer, always keep the
+     * FormatContainer and never fall back to a paragraph, even when it only has a single child.
+     * Set this when the intermediate FormatContainer is persisted during DOM to Content Model conversion
+     * and is later used during formatting.
+     */
+    skipFormatContainerFallbackCheck?: boolean;
 }
 
 /**
@@ -3412,6 +3430,14 @@ export interface DomIndexer {
      * @returns True if successfully updated, otherwise false
      */
     reconcileElementId: (element: HTMLElement) => boolean;
+    /**
+     * When src or a data-* attribute is changed on an indexed IMG element, update the related
+     * ContentModelImage (src property or dataset) so the cached model stays valid.
+     * @param element The element that has an attribute changed
+     * @param attributeName The name of the changed attribute
+     * @returns True if successfully updated, otherwise false
+     */
+    reconcileImageAttribute: (element: HTMLElement, attributeName: string) => boolean;
     /**
      * When child list of editor content is changed, we can use this method to do sync the change from editor into content model.
      * This is mostly used when user start to type in an empty line. In that case browser will remove the existing BR node in the empty line if any,
@@ -6335,7 +6361,7 @@ export interface BeforePasteEvent extends BasePluginEvent<'beforePaste'> {
      */
     readonly htmlAttributes: Record<string, string>;
     /**
-     * Paste type option (as plain text, merge format, normal, as image)
+     * Paste type option (as plain text, merge format, normal, as image, asMarkdown (@see MarkdownPastePlugin ))
      */
     readonly pasteType: PasteType;
     /**
@@ -7667,7 +7693,7 @@ export function createDomToModelContext(editorContext?: EditorContext, ...option
  * @param config A full config object to define how to convert DOM tree to Content Model
  * @param editorContext Context of editor
  */
-export function createDomToModelContextWithConfig(config: DomToModelSettings, editorContext?: EditorContext): any;
+export function createDomToModelContextWithConfig(config: DomToModelSettings, editorContext?: EditorContext): DomToModelContext;
 
 /**
  * Create Dom to Content Model Config object
@@ -10918,6 +10944,23 @@ export function convertMarkdownToContentModel(text: string, options?: MarkdownTo
  */
 export function convertContentModelToMarkdown(model: ContentModelDocument, newLine?: MarkdownLineBreaks): string;
 
+/**
+ * Detect whether the given plain text contains any markdown markup.
+ * Recognizes block-level patterns (headings, blockquotes, lists, horizontal rules, tables)
+ * and inline patterns (bold, italic, strikethrough, links, images).
+ * @param text The plain text to check.
+ * @returns True if the text contains any markdown markup, false otherwise.
+ */
+export function isContentMarkdown(text: string): boolean;
+
+/**
+ * Detect whether the given clipboard content can be interpreted as markdown.
+ * @param editor The editor instance.
+ * @param clipboardData The clipboard data to check.
+ * @returns True if the content can be interpreted as markdown, false otherwise.
+ */
+export function isPastedContentMarkdown(editor: IEditor, clipboardData: ClipboardData): boolean;
+
 /**
  * The characters to add line breaks and new lines
  */
@@ -10949,3 +10992,55 @@ export interface MarkdownToModelOptions {
     direction?: 'ltr' | 'rtl' | undefined;
 }
 
+/**
+ * Markdown paste plugin. Handles the BeforePaste event and, when the pasted content
+ * can be interpreted as markdown, converts the plain text into a Content Model and
+ * pastes it as rich markdown content instead of the original clipboard HTML.
+ */
+export class MarkdownPastePlugin implements EditorPlugin  {
+    private editor;
+    private options;
+    /**
+     * Construct a new instance of MarkdownPastePlugin
+     * @param options Options to control the markdown paste behavior
+     */
+    constructor(options?: MarkdownPasteOptions);
+    /**
+     * Get name of this plugin
+     */
+    getName(): string;
+    /**
+     * The first method that editor will call to a plugin when editor is initializing.
+     * It will pass in the editor instance, plugin should take this chance to save the
+     * editor reference so that it can call to any editor method or format API later.
+     * @param editor The editor object
+     */
+    initialize(editor: IEditor): void;
+    /**
+     * The last method that editor will call to a plugin before it is disposed.
+     * Plugin can take this chance to clear the reference to editor. After this method is
+     * called, plugin should not call to any editor method since it will result in error.
+     */
+    dispose(): void;
+    /**
+     * Core method for a plugin. Once an event happens in editor, editor will call this
+     * method of each plugin to handle the event as long as the event is not handled
+     * exclusively by another plugin.
+     * @param event The event to handle:
+     */
+    onPluginEvent(event: PluginEvent): void;
+}
+
+/**
+ * Options for MarkdownPastePlugin
+ */
+export interface MarkdownPasteOptions {
+    /**
+     * When true, content that can be interpreted as markdown is automatically converted
+     * into rich content on every paste, without requiring an explicit "Paste as Markdown"
+     * command.
+     * @default false
+     */
+    autoConversion: boolean;
+}
+

package/dist/rooster-amd.js

@@ -8019,6 +8019,15 @@ function formatInsertPointWithContentModel(editor, insertPoint, callback, option
             textWithSelection: getShadowTextProcessor(bundle),
         },
         tryGetFromCache: false,
+        // When an element carries "container level" styles such as margin or padding, we first
+        // wrap it in a FormatContainer. After all its child nodes are processed, we decide whether
+        // to keep the FormatContainer or fall back to a plain paragraph when it only wraps a single
+        // paragraph. However, formatInsertPointWithContentModel persists the Content Model group path
+        // during processing so the later formatting callback can still use it (see the
+        // DomToModelContextWithPath interface below). If the FormatContainer falls back to a paragraph,
+        // it is removed from the model and the persisted path becomes invalid. To keep the path valid,
+        // we skip the fallback check here and always keep the FormatContainer when one is needed.
+        skipFormatContainerFallbackCheck: true,
     });
 }
 exports.formatInsertPointWithContentModel = formatInsertPointWithContentModel;
@@ -10103,6 +10112,9 @@ var createContentModel = function (core, option, selectionOverride) {
     var domToModelContext = option
         ? (0, roosterjs_content_model_dom_1.createDomToModelContext)(editorContext, settings.builtIn, settings.customized, option)
         : (0, roosterjs_content_model_dom_1.createDomToModelContextWithConfig)(settings.calculated, editorContext);
+    if (option === null || option === void 0 ? void 0 : option.skipFormatContainerFallbackCheck) {
+        domToModelContext.skipFormatContainerFallbackCheck = true;
+    }
     if (selection) {
         domToModelContext.selection = selection;
     }
@@ -11574,6 +11586,11 @@ var CachePlugin = /** @class */ (function () {
                             _this.invalidateCache();
                         }
                         break;
+                    case 'attribute':
+                        if (!_this.state.domIndexer.reconcileImageAttribute(mutation.element, mutation.attributeName)) {
+                            _this.invalidateCache();
+                        }
+                        break;
                     case 'unknown':
                         _this.invalidateCache();
                         break;
@@ -12105,6 +12122,33 @@ var DomIndexerImpl = /** @class */ (function () {
             return false;
         }
     };
+    DomIndexerImpl.prototype.reconcileImageAttribute = function (element, attributeName) {
+        var _a, _b;
+        if ((0, roosterjs_content_model_dom_1.isElementOfType)(element, 'img')) {
+            var image = (_a = getIndexedSegmentItem(element)) === null || _a === void 0 ? void 0 : _a.segments[0];
+            if ((image === null || image === void 0 ? void 0 : image.segmentType) == 'Image') {
+                if (attributeName == 'src') {
+                    // Use getAttribute('src') instead of retrieving src directly, in case the src
+                    // has port and may be stripped by browser. This matches imageProcessor.
+                    image.src = (_b = element.getAttribute('src')) !== null && _b !== void 0 ? _b : '';
+                    return true;
+                }
+                else if (attributeName.indexOf('data-') == 0) {
+                    // A data-* attribute may be added, modified or removed. Rebuild the whole
+                    // dataset from DOM to keep it in sync, the same way imageProcessor builds it.
+                    var dataset_1 = image.dataset;
+                    (0, roosterjs_content_model_dom_1.getObjectKeys)(dataset_1).forEach(function (key) {
+                        delete dataset_1[key];
+                    });
+                    (0, roosterjs_content_model_dom_1.getObjectKeys)(element.dataset).forEach(function (key) {
+                        dataset_1[key] = element.dataset[key] || '';
+                    });
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
     DomIndexerImpl.prototype.onBlockEntityDelimiter = function (node, entity, parent) {
         if ((0, roosterjs_content_model_dom_1.isNodeOfType)(node, 'ELEMENT_NODE') && (0, roosterjs_content_model_dom_1.isEntityDelimiter)(node) && node.firstChild) {
             var indexedDelimiter = node.firstChild;
@@ -12420,6 +12464,16 @@ var TextMutationObserverImpl = /** @class */ (function () {
                                 (0, roosterjs_content_model_dom_1.isNodeOfType)(target, 'ELEMENT_NODE')) {
                                 _this.onMutation({ type: 'elementId', element: target });
                             }
+                            else if (mutation.attributeName &&
+                                (0, roosterjs_content_model_dom_1.isNodeOfType)(target, 'ELEMENT_NODE') &&
+                                (mutation.attributeName == 'src' ||
+                                    mutation.attributeName.indexOf('data-') == 0)) {
+                                _this.onMutation({
+                                    type: 'attribute',
+                                    element: target,
+                                    attributeName: mutation.attributeName,
+                                });
+                            }
                             else {
                                 // We cannot handle attributes changes on editor content for now
                                 canHandle = false;
@@ -18136,7 +18190,9 @@ var formatContainerProcessorInternal = function (group, element, context, forceF
         if (element.style.fontSize && parseInt(element.style.fontSize) == 0) {
             formatContainer.zeroFontSize = true;
         }
-        if (shouldFallbackToParagraph(formatContainer) && !forceFormatContainer) {
+        if (!context.skipFormatContainerFallbackCheck &&
+            shouldFallbackToParagraph(formatContainer) &&
+            !forceFormatContainer) {
             // For DIV container that only has one paragraph child, container style can be merged into paragraph
             // and no need to have this container
             var paragraph = formatContainer.blocks[0];
@@ -28673,6 +28729,7 @@ function internalIterateSelections(path, callback, option, table, treatAllAsSele
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.setSelection = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.mjs");
 var isGeneralSegment_1 = __webpack_require__(/*! ../typeCheck/isGeneralSegment */ "./packages/roosterjs-content-model-dom/lib/modelApi/typeCheck/isGeneralSegment.ts");
 var mutate_1 = __webpack_require__(/*! ../common/mutate */ "./packages/roosterjs-content-model-dom/lib/modelApi/common/mutate.ts");
 /**
@@ -28710,6 +28767,7 @@ function setSelectionToBlockGroup(group, isInSelection, start, end) {
     });
 }
 function setSelectionToBlock(block, isInSelection, start, end) {
+    var _a;
     switch (block.blockType) {
         case 'BlockGroup':
             return setSelectionToBlockGroup(block, isInSelection, start, end);
@@ -28730,16 +28788,31 @@ function setSelectionToBlock(block, isInSelection, start, end) {
                 return isInSelection;
             });
         case 'Paragraph':
-            var segmentsToDelete_1 = [];
+            var state_1 = {
+                segmentsToDelete: [],
+                boundaryMarkers: [],
+                hasSelectedNonMarker: false,
+            };
             block.segments.forEach(function (segment, i) {
                 isInSelection = handleSelection(isInSelection, segment, start, end, function (isInSelection) {
-                    return setSelectionToSegment(block, segment, isInSelection, segmentsToDelete_1, start, end, i);
+                    return setSelectionToSegment(block, segment, isInSelection, state_1, start, end, i);
                 });
             });
-            if (segmentsToDelete_1.length > 0) {
+            if (state_1.hasSelectedNonMarker) {
+                // This paragraph contains a real (non-marker) selected segment, so any leading/trailing
+                // selection marker of the range is redundant within this paragraph and can be removed.
+                // We only do this within the same paragraph: a boundary marker at a paragraph edge must be
+                // kept to distinguish "selection starts at the beginning of this line" from "selection
+                // starts at the end of the previous line".
+                (_a = state_1.segmentsToDelete).push.apply(_a, (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(state_1.boundaryMarkers), false));
+            }
+            if (state_1.segmentsToDelete.length > 0) {
                 var mutablePara = (0, mutate_1.mutateBlock)(block);
                 var index = void 0;
-                while ((index = segmentsToDelete_1.pop()) !== undefined) {
+                // Sort ascending so the pop()-based splice below always removes the highest index first,
+                // keeping the remaining indices valid (boundary markers may sit before queued deletions).
+                state_1.segmentsToDelete.sort(function (a, b) { return a - b; });
+                while ((index = state_1.segmentsToDelete.pop()) !== undefined) {
                     if (index >= 0) {
                         mutablePara.segments.splice(index, 1);
                     }
@@ -28788,14 +28861,23 @@ function findCell(table, cell) {
         : -1;
     return { row: row, col: col };
 }
-function setSelectionToSegment(paragraph, segment, isInSelection, segmentsToDelete, start, end, i) {
+function setSelectionToSegment(paragraph, segment, isInSelection, state, start, end, i) {
+    if (segment.segmentType != 'SelectionMarker' && isInSelection) {
+        state.hasSelectedNonMarker = true;
+    }
     switch (segment.segmentType) {
         case 'SelectionMarker':
             if (!isInSelection || (segment != start && segment != end)) {
                 // Delete the selection marker when
                 // 1. It is not in selection any more. Or
                 // 2. It is in middle of selection, so no need to have it
-                segmentsToDelete.push(i);
+                state.segmentsToDelete.push(i);
+            }
+            else {
+                // It is a leading/trailing selection marker of a range selection. Keep it for now, but
+                // remember it so it can be removed later if this same paragraph also contains a real
+                // (non-marker) selected segment, in which case the marker is redundant.
+                state.boundaryMarkers.push(i);
             }
             return isInSelection;
         case 'General':
@@ -29236,7 +29318,7 @@ var handleBlockGroupChildren = function (doc, parent, group, context) {
                 (_a = context.domIndexer) === null || _a === void 0 ? void 0 : _a.onBlockEntity(childBlock, group);
             }
         });
-        cleanUpNodeStack(listFormat.nodeStack, context);
+        cleanUpNodeStack(listFormat.nodeStack, context, parent);
         // Remove all rest node if any since they don't appear in content model
         (0, cleanUpRestNodes_1.cleanUpRestNodes)(refNode, context.rewriteFromModel);
     }
@@ -29245,7 +29327,7 @@ var handleBlockGroupChildren = function (doc, parent, group, context) {
     }
 };
 exports.handleBlockGroupChildren = handleBlockGroupChildren;
-function cleanUpNodeStack(nodeStack, context) {
+function cleanUpNodeStack(nodeStack, context, leavingParent) {
     var _a, _b;
     if (nodeStack.length > 0) {
         // Clear list stack, only run to nodeStack[1] because nodeStack[0] is the parent node
@@ -29253,6 +29335,13 @@ function cleanUpNodeStack(nodeStack, context) {
             var node = (_b = (_a = nodeStack.pop()) === null || _a === void 0 ? void 0 : _a.refNode) !== null && _b !== void 0 ? _b : null;
             (0, cleanUpRestNodes_1.cleanUpRestNodes)(node, context.rewriteFromModel);
         }
+        if (leavingParent && nodeStack[0].node == leavingParent) {
+            // When leaving a parent node that is the same with the root of node stack
+            // It means the whole list node stack is being invalidated, so we clear it
+            while (nodeStack.length > 0) {
+                nodeStack.pop();
+            }
+        }
     }
 }
 
@@ -30641,11 +30730,17 @@ exports.MarkdownHeadings = {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.convertContentModelToMarkdown = exports.convertMarkdownToContentModel = void 0;
+exports.MarkdownPastePlugin = exports.isPastedContentMarkdown = exports.isContentMarkdown = exports.convertContentModelToMarkdown = exports.convertMarkdownToContentModel = void 0;
 var convertMarkdownToContentModel_1 = __webpack_require__(/*! ./markdownToModel/convertMarkdownToContentModel */ "./packages/roosterjs-content-model-markdown/lib/markdownToModel/convertMarkdownToContentModel.ts");
 Object.defineProperty(exports, "convertMarkdownToContentModel", ({ enumerable: true, get: function () { return convertMarkdownToContentModel_1.convertMarkdownToContentModel; } }));
 var convertContentModelToMarkdown_1 = __webpack_require__(/*! ./modelToMarkdown/convertContentModelToMarkdown */ "./packages/roosterjs-content-model-markdown/lib/modelToMarkdown/convertContentModelToMarkdown.ts");
 Object.defineProperty(exports, "convertContentModelToMarkdown", ({ enumerable: true, get: function () { return convertContentModelToMarkdown_1.convertContentModelToMarkdown; } }));
+var isContentMarkdown_1 = __webpack_require__(/*! ./publicApi/isContentMarkdown */ "./packages/roosterjs-content-model-markdown/lib/publicApi/isContentMarkdown.ts");
+Object.defineProperty(exports, "isContentMarkdown", ({ enumerable: true, get: function () { return isContentMarkdown_1.isContentMarkdown; } }));
+var isPastedContentMarkdown_1 = __webpack_require__(/*! ./publicApi/isPastedContentMarkdown */ "./packages/roosterjs-content-model-markdown/lib/publicApi/isPastedContentMarkdown.ts");
+Object.defineProperty(exports, "isPastedContentMarkdown", ({ enumerable: true, get: function () { return isPastedContentMarkdown_1.isPastedContentMarkdown; } }));
+var MarkdownPastePlugin_1 = __webpack_require__(/*! ./plugins/MarkdownPastePlugin */ "./packages/roosterjs-content-model-markdown/lib/plugins/MarkdownPastePlugin.ts");
+Object.defineProperty(exports, "MarkdownPastePlugin", ({ enumerable: true, get: function () { return MarkdownPastePlugin_1.MarkdownPastePlugin; } }));
 
 
 /***/ },
@@ -31335,6 +31430,13 @@ function parseInlineSegments(text, segments, state, link) {
     };
     while (i < text.length) {
         var remaining = text.substring(i);
+        // Escaped character: a backslash followed by an ASCII punctuation character emits
+        // that character literally (e.g. "\*" -> "*") and is never treated as a marker.
+        if (text[i] === '\\' && i + 1 < text.length && isEscapable(text[i + 1])) {
+            buffer += text[i + 1];
+            i += 2;
+            continue;
+        }
         // Image: ![alt](url)
         var imgMatch = imagePattern.exec(remaining);
         if (imgMatch && isValidUrl(imgMatch[2])) {
@@ -31398,6 +31500,10 @@ function shouldToggleFormatting(text, index, marker, currentState) {
 function isWhitespace(char) {
     return /\s/.test(char);
 }
+function isEscapable(char) {
+    // Per CommonMark, any ASCII punctuation character may be backslash-escaped.
+    return /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/.test(char);
+}
 function toggleFormatting(state, type) {
     switch (type) {
         case 'bold':
@@ -31901,6 +32007,252 @@ function modelProcessor(model, newLine) {
 exports.modelProcessor = modelProcessor;
 
 
+/***/ },
+
+/***/ "./packages/roosterjs-content-model-markdown/lib/plugins/MarkdownPastePlugin.ts"
+/*!**************************************************************************************!*\
+  !*** ./packages/roosterjs-content-model-markdown/lib/plugins/MarkdownPastePlugin.ts ***!
+  \**************************************************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MarkdownPastePlugin = void 0;
+var roosterjs_content_model_dom_1 = __webpack_require__(/*! roosterjs-content-model-dom */ "./packages/roosterjs-content-model-dom/lib/index.ts");
+var convertMarkdownToContentModel_1 = __webpack_require__(/*! ../markdownToModel/convertMarkdownToContentModel */ "./packages/roosterjs-content-model-markdown/lib/markdownToModel/convertMarkdownToContentModel.ts");
+var isPastedContentMarkdown_1 = __webpack_require__(/*! ../publicApi/isPastedContentMarkdown */ "./packages/roosterjs-content-model-markdown/lib/publicApi/isPastedContentMarkdown.ts");
+var DefaultOptions = {
+    autoConversion: false,
+};
+/**
+ * Markdown paste plugin. Handles the BeforePaste event and, when the pasted content
+ * can be interpreted as markdown, converts the plain text into a Content Model and
+ * pastes it as rich markdown content instead of the original clipboard HTML.
+ */
+var MarkdownPastePlugin = /** @class */ (function () {
+    /**
+     * Construct a new instance of MarkdownPastePlugin
+     * @param options Options to control the markdown paste behavior
+     */
+    function MarkdownPastePlugin(options) {
+        this.editor = null;
+        this.options = options !== null && options !== void 0 ? options : DefaultOptions;
+    }
+    /**
+     * Get name of this plugin
+     */
+    MarkdownPastePlugin.prototype.getName = function () {
+        return 'MarkdownPaste';
+    };
+    /**
+     * The first method that editor will call to a plugin when editor is initializing.
+     * It will pass in the editor instance, plugin should take this chance to save the
+     * editor reference so that it can call to any editor method or format API later.
+     * @param editor The editor object
+     */
+    MarkdownPastePlugin.prototype.initialize = function (editor) {
+        this.editor = editor;
+    };
+    /**
+     * The last method that editor will call to a plugin before it is disposed.
+     * Plugin can take this chance to clear the reference to editor. After this method is
+     * called, plugin should not call to any editor method since it will result in error.
+     */
+    MarkdownPastePlugin.prototype.dispose = function () {
+        this.editor = null;
+    };
+    /**
+     * Core method for a plugin. Once an event happens in editor, editor will call this
+     * method of each plugin to handle the event as long as the event is not handled
+     * exclusively by another plugin.
+     * @param event The event to handle:
+     */
+    MarkdownPastePlugin.prototype.onPluginEvent = function (event) {
+        if (!this.editor || event.eventType != 'beforePaste') {
+            return;
+        }
+        var shouldConvert = event.pasteType === 'asMarkdown' || this.options.autoConversion;
+        if (shouldConvert && (0, isPastedContentMarkdown_1.isPastedContentMarkdown)(this.editor, event.clipboardData)) {
+            convertPastedTextToMarkdown(this.editor, event.fragment, event.clipboardData.text);
+        }
+    };
+    return MarkdownPastePlugin;
+}());
+exports.MarkdownPastePlugin = MarkdownPastePlugin;
+function convertPastedTextToMarkdown(editor, fragment, text) {
+    var model = (0, convertMarkdownToContentModel_1.convertMarkdownToContentModel)(text, {
+        emptyLine: 'merge',
+    });
+    while (fragment.firstChild) {
+        fragment.removeChild(fragment.firstChild);
+    }
+    (0, roosterjs_content_model_dom_1.contentModelToDom)(editor.getDocument(), fragment, model, (0, roosterjs_content_model_dom_1.createModelToDomContext)());
+}
+
+
+/***/ },
+
+/***/ "./packages/roosterjs-content-model-markdown/lib/publicApi/isContentMarkdown.ts"
+/*!**************************************************************************************!*\
+  !*** ./packages/roosterjs-content-model-markdown/lib/publicApi/isContentMarkdown.ts ***!
+  \**************************************************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isContentMarkdown = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "./node_modules/tslib/tslib.es6.mjs");
+// Block-level markdown patterns. A line that matches any of these is considered markdown.
+var BlockPatterns = [
+    /^#{1,6}\s.+/,
+    /^\s*>\s.+/,
+    /^\s*[\*\-\+]\s.+/,
+    /^\s*\d+\.\s.+/,
+    /^---+$/,
+    /^\s*\|.*\|\s*$/, // table row: "| a | b |"
+];
+// Inline markdown patterns. The text contains markdown if any of these match anywhere.
+var InlinePatterns = [
+    /!\[[^\[\]]+\]\([^\)\s]+\)/,
+    /\[[^\[\]]+\]\([^\)\s]+\)/,
+    /\*\*[^\s*][^*]*\*\*/,
+    /(^|[^*])\*[^\s*][^*]*\*([^*]|$)/,
+    /~~[^\s~][^~]*~~/, // strikethrough: ~~text~~
+];
+/**
+ * Detect whether the given plain text contains any markdown markup.
+ * Recognizes block-level patterns (headings, blockquotes, lists, horizontal rules, tables)
+ * and inline patterns (bold, italic, strikethrough, links, images).
+ * @param text The plain text to check.
+ * @returns True if the text contains any markdown markup, false otherwise.
+ */
+function isContentMarkdown(text) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    if (!text || !text.trim()) {
+        return false;
+    }
+    var lines = text.split(/\r\n|\r|\n/);
+    try {
+        for (var lines_1 = (0, tslib_1.__values)(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+            var line = lines_1_1.value;
+            try {
+                for (var BlockPatterns_1 = (e_2 = void 0, (0, tslib_1.__values)(BlockPatterns)), BlockPatterns_1_1 = BlockPatterns_1.next(); !BlockPatterns_1_1.done; BlockPatterns_1_1 = BlockPatterns_1.next()) {
+                    var pattern = BlockPatterns_1_1.value;
+                    if (pattern.test(line)) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (BlockPatterns_1_1 && !BlockPatterns_1_1.done && (_b = BlockPatterns_1.return)) _b.call(BlockPatterns_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var InlinePatterns_1 = (0, tslib_1.__values)(InlinePatterns), InlinePatterns_1_1 = InlinePatterns_1.next(); !InlinePatterns_1_1.done; InlinePatterns_1_1 = InlinePatterns_1.next()) {
+            var pattern = InlinePatterns_1_1.value;
+            if (pattern.test(text)) {
+                return true;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (InlinePatterns_1_1 && !InlinePatterns_1_1.done && (_c = InlinePatterns_1.return)) _c.call(InlinePatterns_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return false;
+}
+exports.isContentMarkdown = isContentMarkdown;
+
+
+/***/ },
+
+/***/ "./packages/roosterjs-content-model-markdown/lib/publicApi/isPastedContentMarkdown.ts"
+/*!********************************************************************************************!*\
+  !*** ./packages/roosterjs-content-model-markdown/lib/publicApi/isPastedContentMarkdown.ts ***!
+  \********************************************************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isPastedContentMarkdown = void 0;
+var isContentMarkdown_1 = __webpack_require__(/*! ./isContentMarkdown */ "./packages/roosterjs-content-model-markdown/lib/publicApi/isContentMarkdown.ts");
+// Tags that are considered "thin wrappers", which only add structure (such as line breaks)
+// around the plain text without applying any real formatting to its content.
+var ThinWrapperTags = new Set(['DIV', 'P', 'BR', 'SPAN']);
+var AllowedAttributes = new Set(['class', 'style']);
+/**
+ * Detect whether the given clipboard content can be interpreted as markdown.
+ * @param editor The editor instance.
+ * @param clipboardData The clipboard data to check.
+ * @returns True if the content can be interpreted as markdown, false otherwise.
+ */
+function isPastedContentMarkdown(editor, clipboardData) {
+    var text = clipboardData.text, rawHtml = clipboardData.rawHtml;
+    if (!text || !text.trim()) {
+        return false;
+    }
+    if ((0, isContentMarkdown_1.isContentMarkdown)(text)) {
+        if (!rawHtml) {
+            return true;
+        }
+        var doc = editor.getDocument();
+        var trustedHTMLHandler = editor.getDOMCreator();
+        var fragment = parseHtmlToFragment(rawHtml, doc, trustedHTMLHandler);
+        return isThinWrapperOfPlainText(fragment, text);
+    }
+    return false;
+}
+exports.isPastedContentMarkdown = isPastedContentMarkdown;
+function isThinWrapperOfPlainText(fragment, text) {
+    var elements = fragment.querySelectorAll('*');
+    for (var i = 0; i < elements.length; i++) {
+        var element = elements[i];
+        if (!ThinWrapperTags.has(element.tagName)) {
+            return false;
+        }
+        for (var j = 0; j < element.attributes.length; j++) {
+            var attr = element.attributes[j];
+            if (!AllowedAttributes.has(attr.name) && !attr.name.startsWith('data-')) {
+                return false;
+            }
+        }
+    }
+    return removeWhitespace(fragment.textContent || '') === removeWhitespace(text);
+}
+function removeWhitespace(text) {
+    return text.replace(/\s/g, '');
+}
+function parseHtmlToFragment(html, doc, trustedHTMLHandler) {
+    var parsedDoc = trustedHTMLHandler.htmlToDOM(html);
+    var fragment = doc.createDocumentFragment();
+    var body = parsedDoc === null || parsedDoc === void 0 ? void 0 : parsedDoc.body;
+    if (body) {
+        while (body.firstChild) {
+            fragment.appendChild(body.firstChild);
+        }
+    }
+    return fragment;
+}
+
+
 /***/ },
 
 /***/ "./packages/roosterjs-content-model-plugins/lib/announce/AnnouncePlugin.ts"