@gravity-ui/markdown-editor 14.4.0 → 14.5.1

package/build/esm/bundle/sticky/sticky.css

@@ -15,7 +15,7 @@
   position: absolute;
   inset: var(--g-md-toolbar-sticky-inset, -4px);
   content: "";
-  border: 1px solid var(--g-color-line-generic-solid);
+  border: var(--g-md-toolbar-sticky-border, 1px solid var(--g-color-line-generic-solid));
   border-radius: 4px;
   background-color: var(--g-color-base-background);
 }

package/build/esm/bundle/types.d.ts

@@ -109,6 +109,8 @@ export declare type MarkdownEditorMarkupConfig = {
     keymaps?: CreateCodemirrorParams['keymaps'];
     /** Overrides the default placeholder content. */
     placeholder?: CreateCodemirrorParams['placeholder'];
+    /** Enable HTML parsing when pasting content. */
+    parseHtmlOnPaste?: boolean;
     /**
      * Additional language data for markdown language in codemirror.
      * Can be used to configure additional autocompletions and others.

package/build/esm/extensions/behavior/Clipboard/utils.d.ts

@@ -3,6 +3,7 @@ export declare enum DataTransferType {
     Text = "text/plain",
     Html = "text/html",
     Yfm = "text/yfm",
+    Rtf = "text/rtf",
     UriList = "text/uri-list",
     VSCodeData = "vscode-editor-data",
     Files = "Files"

package/build/esm/extensions/behavior/Clipboard/utils.js

@@ -4,6 +4,7 @@ export var DataTransferType;
     DataTransferType["Text"] = "text/plain";
     DataTransferType["Html"] = "text/html";
     DataTransferType["Yfm"] = "text/yfm";
+    DataTransferType["Rtf"] = "text/rtf";
     DataTransferType["UriList"] = "text/uri-list";
     DataTransferType["VSCodeData"] = "vscode-editor-data";
     DataTransferType["Files"] = "Files";

package/build/esm/extensions/markdown/CodeBlock/handle-paste.js

@@ -1,4 +1,4 @@
-import { DataTransferType } from '../../behavior/Clipboard/utils';
+import { DataTransferType, isVSCode, tryParseVSCodeData } from '../../../utils/clipboard';
 import { cbType, codeBlockLangAttr } from './const';
 export const handlePaste = (view, e) => {
     if (!e.clipboardData || view.state.selection.$from.parent.type.spec.code)
@@ -20,7 +20,7 @@ function getCodeData(data) {
         let mode;
         if (isVSCode(data)) {
             editor = 'vscode';
-            mode = (_a = tryCatch(() => JSON.parse(data.getData(DataTransferType.VSCodeData)))) === null || _a === void 0 ? void 0 : _a.mode;
+            mode = (_a = tryParseVSCodeData(data)) === null || _a === void 0 ? void 0 : _a.mode;
         }
         else
             return null;
@@ -28,15 +28,3 @@ function getCodeData(data) {
     }
     return null;
 }
-function isVSCode(data) {
-    return data.types.includes(DataTransferType.VSCodeData);
-}
-function tryCatch(fn) {
-    try {
-        return fn();
-    }
-    catch (e) {
-        console.error(e);
-    }
-    return undefined;
-}

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/const.d.ts

@@ -3,5 +3,12 @@ export declare enum CheckboxNode {
     Input = "checkbox_input",
     Label = "checkbox_label"
 }
+export declare const CheckboxAttr: {
+    readonly Class: "class";
+    readonly Type: "type";
+    readonly Id: "id";
+    readonly Checked: "checked";
+    readonly For: "for";
+};
 export declare const idPrefix = "yfm-editor-checkbox";
 export declare const b: import("@bem-react/classname").ClassNameFormatter;

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/const.js

@@ -5,5 +5,12 @@ export var CheckboxNode;
     CheckboxNode["Input"] = "checkbox_input";
     CheckboxNode["Label"] = "checkbox_label";
 })(CheckboxNode || (CheckboxNode = {}));
+export const CheckboxAttr = {
+    Class: 'class',
+    Type: 'type',
+    Id: 'id',
+    Checked: 'checked',
+    For: 'for',
+};
 export const idPrefix = 'yfm-editor-checkbox';
 export const b = cn('checkbox');

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/index.d.ts

@@ -1,6 +1,6 @@
 import type { NodeSpec } from 'prosemirror-model';
 import type { ExtensionAuto, ExtensionNodeSpec } from '../../../../core';
-export { CheckboxNode } from './const';
+export { CheckboxAttr, CheckboxNode } from './const';
 export declare const checkboxType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
 export declare const checkboxLabelType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
 export declare const checkboxInputType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/index.js

@@ -4,7 +4,7 @@ import { CheckboxNode, b, idPrefix } from './const';
 import { parserTokens } from './parser';
 import { getSchemaSpecs } from './schema';
 import { serializerTokens } from './serializer';
-export { CheckboxNode } from './const';
+export { CheckboxAttr, CheckboxNode } from './const';
 export const checkboxType = nodeTypeFactory(CheckboxNode.Checkbox);
 export const checkboxLabelType = nodeTypeFactory(CheckboxNode.Label);
 export const checkboxInputType = nodeTypeFactory(CheckboxNode.Input);

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/schema.d.ts

@@ -1,5 +1,5 @@
 import type { NodeSpec } from 'prosemirror-model';
 import { PlaceholderOptions } from '../../../../utils/placeholder';
-import { CheckboxNode } from '../const';
+import { CheckboxNode } from './const';
 import type { CheckboxSpecsOptions } from './index';
 export declare const getSchemaSpecs: (opts?: Pick<CheckboxSpecsOptions, 'checkboxLabelPlaceholder'>, placeholder?: PlaceholderOptions) => Record<CheckboxNode, NodeSpec>;

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/schema.js

@@ -1,4 +1,4 @@
-import { CheckboxNode, b } from '../const';
+import { CheckboxAttr, CheckboxNode, b } from './const';
 const DEFAULT_LABEL_PLACEHOLDER = 'Checkbox';
 export const getSchemaSpecs = (opts, placeholder) => {
     var _a, _b;
@@ -10,7 +10,7 @@ export const getSchemaSpecs = (opts, placeholder) => {
             allowSelection: false,
             parseDOM: [],
             attrs: {
-                class: { default: b() },
+                [CheckboxAttr.Class]: { default: b() },
             },
             toDOM(node) {
                 return ['div', node.attrs, 0];
@@ -21,9 +21,9 @@ export const getSchemaSpecs = (opts, placeholder) => {
             group: 'block',
             parseDOM: [],
             attrs: {
-                type: { default: 'checkbox' },
-                id: { default: null },
-                checked: { default: null },
+                [CheckboxAttr.Type]: { default: 'checkbox' },
+                [CheckboxAttr.Id]: { default: null },
+                [CheckboxAttr.Checked]: { default: null },
             },
             toDOM(node) {
                 return ['div', node.attrs];
@@ -39,12 +39,12 @@ export const getSchemaSpecs = (opts, placeholder) => {
                 {
                     tag: `span[class="${b('label')}"]`,
                     getAttrs: (node) => ({
-                        for: node.getAttribute('for') || '',
+                        [CheckboxAttr.For]: node.getAttribute(CheckboxAttr.For) || '',
                     }),
                 },
             ],
             attrs: {
-                for: { default: null },
+                [CheckboxAttr.For]: { default: null },
             },
             escapeText: false,
             placeholder: {

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/serializer.d.ts

@@ -1,3 +1,3 @@
 import { SerializerNodeToken } from '../../../../core';
-import { CheckboxNode } from '../const';
+import { CheckboxNode } from './const';
 export declare const serializerTokens: Record<CheckboxNode, SerializerNodeToken>;

package/build/esm/extensions/yfm/Checkbox/CheckboxSpecs/serializer.js

@@ -1,12 +1,12 @@
 import { getPlaceholderContent } from '../../../../utils/placeholder';
-import { CheckboxNode } from '../const';
+import { CheckboxAttr, CheckboxNode } from './const';
 export const serializerTokens = {
     [CheckboxNode.Checkbox]: (state, node) => {
         state.renderInline(node);
         state.closeBlock(node);
     },
     [CheckboxNode.Input]: (state, node) => {
-        const checked = node.attrs.checked === 'true';
+        const checked = node.attrs[CheckboxAttr.Checked] === 'true';
         state.write(`[${checked ? 'X' : ' '}] `);
     },
     [CheckboxNode.Label]: (state, node, _, idx) => {

package/build/esm/extensions/yfm/Checkbox/const.d.ts

@@ -1 +1 @@
-export { CheckboxNode, b } from './CheckboxSpecs/const';
+export { CheckboxAttr, CheckboxNode, b } from './CheckboxSpecs/const';

package/build/esm/extensions/yfm/Checkbox/const.js

@@ -1 +1 @@
-export { CheckboxNode, b } from './CheckboxSpecs/const';
+export { CheckboxAttr, CheckboxNode, b } from './CheckboxSpecs/const';

package/build/esm/extensions/yfm/Checkbox/index.d.ts

@@ -1,8 +1,8 @@
 import type { Action, ExtensionAuto } from '../../../core';
-import { CheckboxSpecsOptions } from './CheckboxSpecs';
+import { type CheckboxSpecsOptions } from './CheckboxSpecs';
 import './index.css';
 declare const checkboxAction = "addCheckbox";
-export { CheckboxNode, checkboxType, checkboxLabelType, checkboxInputType } from './CheckboxSpecs';
+export { CheckboxAttr, CheckboxNode, checkboxType, checkboxLabelType, checkboxInputType, } from './CheckboxSpecs';
 export declare type CheckboxOptions = Pick<CheckboxSpecsOptions, 'checkboxLabelPlaceholder'> & {};
 export declare const Checkbox: ExtensionAuto<CheckboxOptions>;
 declare global {

package/build/esm/extensions/yfm/Checkbox/index.js

@@ -1,49 +1,14 @@
-import { replaceParentNodeOfType } from 'prosemirror-utils';
 import { nodeInputRule } from '../../../utils/inputrules';
-import { pType } from '../../base/BaseSchema';
 import { CheckboxSpecs } from './CheckboxSpecs';
 import { addCheckbox } from './actions';
-import { CheckboxNode, b } from './const';
+import { CheckboxInputView } from './nodeviews';
 import { keymapPlugin } from './plugin';
 import { checkboxInputType, checkboxType } from './utils';
 import './index.css';
 const checkboxAction = 'addCheckbox';
-export { CheckboxNode, checkboxType, checkboxLabelType, checkboxInputType } from './CheckboxSpecs';
+export { CheckboxAttr, CheckboxNode, checkboxType, checkboxLabelType, checkboxInputType, } from './CheckboxSpecs';
 export const Checkbox = (builder, opts) => {
-    builder.use(CheckboxSpecs, Object.assign(Object.assign({}, opts), { inputView: () => (node, view, getPos) => {
-            const dom = document.createElement('input');
-            for (const attr in node.attrs) {
-                if (node.attrs[attr])
-                    dom.setAttribute(attr, node.attrs[attr]);
-            }
-            dom.setAttribute('class', b('input'));
-            dom.addEventListener('click', (e) => {
-                const elem = e.target;
-                const checkedAttr = elem.getAttribute('checked');
-                const checked = checkedAttr ? '' : 'true';
-                const pos = getPos();
-                if (pos !== undefined) {
-                    view.dispatch(view.state.tr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { checked })));
-                }
-                elem.setAttribute('checked', checked);
-            });
-            return {
-                dom,
-                ignoreMutation: () => true,
-                update: () => true,
-                destroy() {
-                    const pos = getPos();
-                    if (pos !== undefined) {
-                        const resolved = view.state.doc.resolve(pos);
-                        if (resolved.parent.type.name === CheckboxNode.Checkbox &&
-                            resolved.parent.lastChild) {
-                            view.dispatch(replaceParentNodeOfType(resolved.parent.type, pType(view.state.schema).create(resolved.parent.lastChild.content))(view.state.tr));
-                        }
-                    }
-                    dom.remove();
-                },
-            };
-        } }));
+    builder.use(CheckboxSpecs, Object.assign(Object.assign({}, opts), { inputView: () => CheckboxInputView.create }));
     builder
         .addPlugin(keymapPlugin, builder.Priority.High)
         .addAction(checkboxAction, () => addCheckbox())

package/build/esm/extensions/yfm/Checkbox/nodeviews.d.ts

@@ -0,0 +1,16 @@
+import type { Node } from 'prosemirror-model';
+import type { NodeView, NodeViewConstructor } from 'prosemirror-view';
+export declare class CheckboxInputView implements NodeView {
+    static create: NodeViewConstructor;
+    dom: HTMLInputElement;
+    private _node;
+    private _view;
+    private _getPos;
+    private constructor();
+    ignoreMutation(): boolean;
+    update(node: Node): boolean;
+    destroy(): void;
+    private _createDomElem;
+    private _applyNodeAttrsToDomElem;
+    private _onInputClick;
+}

package/build/esm/extensions/yfm/Checkbox/nodeviews.js

@@ -0,0 +1,52 @@
+var _a;
+import { CheckboxAttr, b } from './const';
+export class CheckboxInputView {
+    constructor(node, view, getPos) {
+        this._onInputClick = (event) => {
+            if (event.target instanceof HTMLInputElement) {
+                const { checked } = event.target;
+                const pos = this._getPos();
+                if (pos !== undefined)
+                    this._view.dispatch(this._view.state.tr.setNodeAttribute(pos, CheckboxAttr.Checked, checked ? 'true' : null));
+            }
+            this._view.focus();
+        };
+        this._node = node;
+        this._view = view;
+        this._getPos = getPos;
+        this.dom = this._createDomElem();
+        this._applyNodeAttrsToDomElem();
+    }
+    ignoreMutation() {
+        return true;
+    }
+    update(node) {
+        if (node.type !== this._node.type)
+            return false;
+        this._node = node;
+        this._applyNodeAttrsToDomElem();
+        return true;
+    }
+    destroy() {
+        this.dom.removeEventListener('click', this._onInputClick);
+    }
+    _createDomElem() {
+        const dom = document.createElement('input');
+        dom.setAttribute('class', b('input'));
+        dom.addEventListener('click', this._onInputClick);
+        return dom;
+    }
+    _applyNodeAttrsToDomElem() {
+        const { dom, _node: node } = this;
+        for (const [key, value] of Object.entries(node.attrs)) {
+            if (value)
+                dom.setAttribute(key, value);
+            else
+                dom.removeAttribute(key);
+        }
+        const checked = node.attrs[CheckboxAttr.Checked] === 'true';
+        this.dom.checked = checked;
+    }
+}
+_a = CheckboxInputView;
+CheckboxInputView.create = (node, view, getPos) => new _a(node, view, getPos);

package/build/esm/extensions/yfm/YfmFile/YfmFileSpecs/const.d.ts

@@ -1,5 +1,17 @@
+import { FileHtmlAttr } from '@diplodoc/file-extension';
 import type { AttributeSpec } from 'prosemirror-model';
 export declare const yfmFileNodeName = "yfm_file";
+export declare const YfmFileAttr: {
+    readonly Markup: "data-markup";
+    readonly Name: FileHtmlAttr.Download;
+    readonly Link: FileHtmlAttr.Href;
+    readonly ReferrerPolicy: FileHtmlAttr.ReferrerPolicy;
+    readonly Rel: FileHtmlAttr.Rel;
+    readonly Target: FileHtmlAttr.Target;
+    readonly Type: FileHtmlAttr.Type;
+    readonly Lang: FileHtmlAttr.HrefLang;
+};
+export declare const YFM_FILE_DIRECTIVE_ATTRS: readonly string[];
 export declare const KNOWN_ATTRS: readonly string[];
 export declare const REQUIRED_ATTRS: string[];
 export declare const fileNodeAttrsSpec: Record<string, AttributeSpec>;

package/build/esm/extensions/yfm/YfmFile/YfmFileSpecs/const.js

@@ -1,5 +1,22 @@
-import { FILE_KNOWN_ATTRS, FILE_REQUIRED_ATTRS, FILE_TOKEN, FILE_TO_LINK_ATTRS_MAP, } from '@diplodoc/file-extension';
+import { FILE_KNOWN_ATTRS, FILE_REQUIRED_ATTRS, FILE_TOKEN, FILE_TO_LINK_ATTRS_MAP, FileHtmlAttr, } from '@diplodoc/file-extension';
 export const yfmFileNodeName = FILE_TOKEN;
+export const YfmFileAttr = {
+    Markup: 'data-markup',
+    Name: FileHtmlAttr.Download,
+    Link: FileHtmlAttr.Href,
+    ReferrerPolicy: FileHtmlAttr.ReferrerPolicy,
+    Rel: FileHtmlAttr.Rel,
+    Target: FileHtmlAttr.Target,
+    Type: FileHtmlAttr.Type,
+    Lang: FileHtmlAttr.HrefLang,
+};
+export const YFM_FILE_DIRECTIVE_ATTRS = [
+    YfmFileAttr.ReferrerPolicy,
+    YfmFileAttr.Rel,
+    YfmFileAttr.Target,
+    YfmFileAttr.Type,
+    YfmFileAttr.Lang,
+];
 export const KNOWN_ATTRS = FILE_KNOWN_ATTRS.map((attrName) => {
     if (attrName in FILE_TO_LINK_ATTRS_MAP)
         return FILE_TO_LINK_ATTRS_MAP[attrName];
@@ -10,7 +27,9 @@ export const REQUIRED_ATTRS = FILE_REQUIRED_ATTRS.map((attrName) => {
         return FILE_TO_LINK_ATTRS_MAP[attrName];
     return attrName;
 });
-export const fileNodeAttrsSpec = {};
+export const fileNodeAttrsSpec = {
+    [YfmFileAttr.Markup]: { default: null },
+};
 for (const attrName of KNOWN_ATTRS) {
     const attrSpec = (fileNodeAttrsSpec[attrName] = {});
     if (!REQUIRED_ATTRS.includes(attrName)) {

package/build/esm/extensions/yfm/YfmFile/YfmFileSpecs/index.d.ts

@@ -1,4 +1,11 @@
 import type { Extension } from '../../../../core';
-export { yfmFileNodeName } from './const';
+export { yfmFileNodeName, YfmFileAttr } from './const';
 export declare const fileType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+declare global {
+    namespace MarkdownEditor {
+        interface DirectiveSyntaxAdditionalSupportedExtensions {
+            yfmFile: true;
+        }
+    }
+}
 export declare const YfmFileSpecs: Extension;

package/build/esm/extensions/yfm/YfmFile/YfmFileSpecs/index.js

@@ -1,10 +1,14 @@
 import { FILE_MARKUP_PREFIX, FileClassName, FileHtmlAttr, transform as fileTransform, } from '@diplodoc/file-extension';
 import { nodeTypeFactory } from '../../../../utils/schema';
-import { KNOWN_ATTRS, LINK_TO_FILE_ATTRS_MAP, fileNodeAttrsSpec, yfmFileNodeName } from './const';
-export { yfmFileNodeName } from './const';
+import { KNOWN_ATTRS, LINK_TO_FILE_ATTRS_MAP, YFM_FILE_DIRECTIVE_ATTRS, YfmFileAttr, fileNodeAttrsSpec, yfmFileNodeName, } from './const';
+export { yfmFileNodeName, YfmFileAttr } from './const';
 export const fileType = nodeTypeFactory(yfmFileNodeName);
 export const YfmFileSpecs = (builder) => {
-    builder.configureMd((md) => md.use(fileTransform({ bundle: false })));
+    const directiveContext = builder.context.get('directiveSyntax');
+    builder.configureMd((md) => md.use(fileTransform({
+        bundle: false,
+        directiveSyntax: directiveContext === null || directiveContext === void 0 ? void 0 : directiveContext.mdPluginValueFor('yfmFile'),
+    })));
     builder.addNode(yfmFileNodeName, () => ({
         spec: {
             group: 'inline',
@@ -48,15 +52,20 @@ export const YfmFileSpecs = (builder) => {
                 name: yfmFileNodeName,
                 type: 'node',
                 getAttrs: (tok) => {
-                    var _a;
-                    return Object.fromEntries((_a = tok.attrs) !== null && _a !== void 0 ? _a : []);
+                    const attrs = Object.fromEntries(tok.attrs || []);
+                    attrs[YfmFileAttr.Markup] = tok.markup;
+                    return attrs;
                 },
             },
         },
         toMd: (state, node) => {
+            if (directiveContext === null || directiveContext === void 0 ? void 0 : directiveContext.shouldSerializeToDirective('yfmFile', node.attrs[YfmFileAttr.Markup])) {
+                state.write(serializeToDirective(node));
+                return;
+            }
             const attrsStr = Object.entries(node.attrs)
                 .reduce((arr, [key, value]) => {
-                if (value) {
+                if (key !== YfmFileAttr.Markup && value) {
                     if (key in LINK_TO_FILE_ATTRS_MAP) {
                         key = LINK_TO_FILE_ATTRS_MAP[key];
                     }
@@ -69,3 +78,17 @@ export const YfmFileSpecs = (builder) => {
         },
     }));
 };
+function serializeToDirective(node) {
+    const filename = node.attrs[YfmFileAttr.Name] || '';
+    const filelink = node.attrs[YfmFileAttr.Link] || '';
+    let fileMarkup = `:file[${filename}](${filelink})`;
+    const attrs = YFM_FILE_DIRECTIVE_ATTRS.reduce((acc, key) => {
+        const value = node.attrs[key];
+        if (value)
+            acc.push(`${key}="${value}"`);
+        return acc;
+    }, []);
+    if (attrs.length)
+        fileMarkup += `{${attrs.join(' ')}}`;
+    return fileMarkup;
+}

package/build/esm/markup/codemirror/create.d.ts

@@ -20,6 +20,7 @@ export declare type CreateCodemirrorParams = {
     onScroll: (event: Event) => void;
     reactRenderer: ReactRenderStorage;
     uploadHandler?: FileUploadHandler;
+    parseHtmlOnPaste?: boolean;
     parseInsertedUrlAsImage?: ParseInsertedUrlAsImage;
     needImageDimensions?: boolean;
     enableNewImageSizeCalculation?: boolean;

package/build/esm/markup/codemirror/create.js

@@ -3,19 +3,20 @@ import { defaultKeymap, history, historyKeymap, indentWithTab, insertNewlineKeep
 import { syntaxHighlighting } from '@codemirror/language';
 import { EditorView, keymap, placeholder } from '@codemirror/view';
 import { ActionName } from '../../bundle/config/action-names';
-import { DataTransferType } from '../../extensions/behavior/Clipboard/utils';
 import { logger } from '../../logger';
 import { Action as A, formatter as f } from '../../shortcuts';
+import { DataTransferType, shouldSkipHtmlConversion } from '../../utils/clipboard';
 import { insertImages, insertLink, toH1, toH2, toH3, toH4, toH5, toH6, toggleBold, toggleItalic, toggleStrikethrough, toggleUnderline, wrapToCodeBlock, wrapToInlineCode, wrapToYfmCut, wrapToYfmNote, } from '../commands';
 import { DirectiveSyntaxFacet } from './directive-facet';
 import { FileUploadHandlerFacet } from './files-upload-facet';
 import { gravityHighlightStyle, gravityTheme } from './gravity';
+import { MarkdownConverter } from './html-to-markdown/converters';
 import { PairingCharactersExtension } from './pairing-chars';
 import { ReactRendererFacet } from './react-facet';
 import { SearchPanelPlugin } from './search-plugin/plugin';
 import { yfmLang } from './yfm';
 export function createCodemirror(params) {
-    const { doc, reactRenderer, onCancel, onScroll, onSubmit, onChange, onDocChange, disabledExtensions = {}, keymaps = [], receiver, yfmLangOptions, extensions: extraExtensions, placeholder: placeholderContent, autocompletion: autocompletionConfig, parseInsertedUrlAsImage, directiveSyntax, } = params;
+    const { doc, reactRenderer, onCancel, onScroll, onSubmit, onChange, onDocChange, disabledExtensions = {}, keymaps = [], receiver, yfmLangOptions, extensions: extraExtensions, placeholder: placeholderContent, autocompletion: autocompletionConfig, parseHtmlOnPaste, parseInsertedUrlAsImage, directiveSyntax, } = params;
     const extensions = [gravityTheme, placeholder(placeholderContent)];
     if (!disabledExtensions.history) {
         extensions.push(history());
@@ -67,7 +68,43 @@ export function createCodemirror(params) {
         },
         paste(event, editor) {
             var _a;
-            if (event.clipboardData && parseInsertedUrlAsImage) {
+            if (!event.clipboardData)
+                return;
+            // if clipboard contains YFM content - avoid any meddling with pasted content
+            // since text/yfm will contain valid markdown
+            const yfmContent = event.clipboardData.getData(DataTransferType.Yfm);
+            if (yfmContent) {
+                event.preventDefault();
+                editor.dispatch(editor.state.replaceSelection(yfmContent));
+                return;
+            }
+            // checking if a copy buffer content is suitable for convertion
+            const shouldSkipHtml = shouldSkipHtmlConversion(event.clipboardData);
+            // if we have text/html inside copy/paste buffer
+            const htmlContent = event.clipboardData.getData(DataTransferType.Html);
+            // if we pasting markdown from VsCode we need skip html transformation
+            if (htmlContent && parseHtmlOnPaste && !shouldSkipHtml) {
+                let parsedMarkdownMarkup;
+                try {
+                    const parser = new DOMParser();
+                    const htmlDoc = parser.parseFromString(htmlContent, 'text/html');
+                    const converter = new MarkdownConverter();
+                    parsedMarkdownMarkup = converter.processNode(htmlDoc.body).trim();
+                }
+                catch (e) {
+                    // The code is pretty new and there might be random issues we haven't caught yet,
+                    // especially with invalid HTML or weird DOM parsing errors.
+                    // If something goes wrong, I just want to fall back to the "default pasting"
+                    // rather than break the entire experience for the user.
+                    logger.error(e);
+                }
+                if (parsedMarkdownMarkup !== undefined) {
+                    event.preventDefault();
+                    editor.dispatch(editor.state.replaceSelection(parsedMarkdownMarkup));
+                    return;
+                }
+            }
+            if (parseInsertedUrlAsImage) {
                 const { imageUrl, title } = parseInsertedUrlAsImage((_a = event.clipboardData.getData(DataTransferType.Text)) !== null && _a !== void 0 ? _a : '') || {};
                 if (!imageUrl) {
                     return;

package/build/esm/markup/codemirror/html-to-markdown/converters.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Interface defining methods for visiting different types of HTML nodes.
+ * Each method corresponds to a specific HTML element type and returns its Markdown representation.
+ */
+export interface HTMLNodeVisitor {
+    /** Converts a text node to Markdown */
+    visitText(node: Text): string;
+    /** Converts an anchor element to Markdown link syntax */
+    visitLink(node: HTMLAnchorElement): string;
+    /** Converts a header element to Markdown heading syntax */
+    visitHeader(node: HTMLElement, level: number): string;
+    /** Converts a paragraph element to Markdown */
+    visitParagraph(node: HTMLElement): string;
+    /** Converts formatting elements (bold, italic, etc.) to Markdown */
+    visitFormatting(node: HTMLElement): string;
+    /** Converts code elements to Markdown inline code syntax */
+    visitCode(node: HTMLElement): string;
+    /** Handles generic HTML elements with no specific Markdown conversion */
+    visitGeneric(node: HTMLElement): string;
+    /** Converts an HTML div element to Markdown format, adding a single newline */
+    visitDiv(node: HTMLElement): string;
+    /** Converts an HTML br element to a newline in Markdown */
+    visitBr(): string;
+    /** Converts a table row element to Markdown */
+    visitTableRow(node: HTMLTableRowElement): string;
+    /** Converts an HTML table element to Markdown table format */
+    visitTable(node: HTMLTableElement): string;
+    /** Convert img tag to Markdown image format */
+    visitImage(node: HTMLImageElement): string;
+}
+/**
+ * Main converter class that implements the visitor interface to convert HTML to Markdown.
+ * Uses the Chain of Responsibility pattern for handling different node types.
+ */
+export declare class MarkdownConverter implements HTMLNodeVisitor {
+    private handler;
+    constructor();
+    /**
+     * Converts a text node to Markdown, escaping special characters.
+     */
+    visitText(node: Text): string;
+    /**
+     * Converts an HTML anchor element to Markdown link syntax.
+     */
+    visitLink(node: HTMLAnchorElement): string;
+    /**
+     * Converts an HTML heading element to Markdown heading syntax.
+     */
+    visitHeader(node: HTMLElement, level: number): string;
+    /**
+     * Converts an HTML paragraph to Markdown format.
+     */
+    visitParagraph(node: HTMLElement): string;
+    /**
+     * Applies Markdown formatting (bold, italic, etc.) to text content.
+     */
+    visitFormatting(node: HTMLElement): string;
+    /**
+     * Converts HTML code elements to Markdown inline code syntax.
+     */
+    visitCode(node: HTMLElement): string;
+    /**
+     * Handles generic HTML elements by processing their children.
+     */
+    visitGeneric(node: HTMLElement): string;
+    /**
+     * Converts an HTML div element to Markdown format, adding a single newline.
+     */
+    visitDiv(node: HTMLElement): string;
+    /**
+     * Converts an HTML br element to a newline in Markdown.
+     */
+    visitBr(): string;
+    /**
+     * Converts an HTML table row element to Markdown table row format.
+     */
+    visitTableRow(node: HTMLTableRowElement): string;
+    /**
+     * Converts an HTML table element to Markdown table format.
+     */
+    visitTable(node: HTMLTableElement): string;
+    /**
+     * Converts img tag to Markdown image format
+     */
+    visitImage(node: HTMLImageElement): string;
+    /**
+     * Processes a single node using the handler chain.
+     */
+    processNode(node: Node): string;
+    /**
+     * Creates and links together handlers in a specific order implementing the Chain of Responsibility pattern.
+     * @returns The first handler in the chain
+     */
+    private setupHandlerChain;
+    /**
+     * Recursively collects and processes text content from a node and its children.
+     */
+    private collectTextContent;
+    /**
+     * Collects raw text content from code elements.
+     */
+    private collectCodeContent;
+    /**
+     * Processes all child nodes of a given node.
+     */
+    private processChildren;
+    /**
+     * Gets the first handler in the chain.
+     */
+    private getHandler;
+}