@gravity-ui/markdown-editor 13.0.0

package/build/esm/extensions/markdown/Blockquote/const.d.ts

@@ -0,0 +1,5 @@
+export { blockquoteNodeName, blockquoteType, isBlockqouteNode } from './BlockquoteSpecs';
+/** @deprecated Use `blockquoteNodeName` instead */
+export declare const blockquote = "blockquote";
+/** @deprecated Use `blockquoteType` instead */
+export declare const bqType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;

package/build/esm/extensions/markdown/Blockquote/const.js

@@ -0,0 +1,6 @@
+import { blockquoteNodeName, blockquoteType } from './BlockquoteSpecs';
+export { blockquoteNodeName, blockquoteType, isBlockqouteNode } from './BlockquoteSpecs';
+/** @deprecated Use `blockquoteNodeName` instead */
+export const blockquote = blockquoteNodeName;
+/** @deprecated Use `blockquoteType` instead */
+export const bqType = blockquoteType;

package/build/esm/extensions/markdown/Blockquote/index.d.ts

@@ -0,0 +1,14 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { blockquote, blockquoteNodeName, blockquoteType } from './const';
+declare const bqAction = "quote";
+export declare type BlockquoteOptions = {
+    qouteKey?: string | null;
+};
+export declare const Blockquote: ExtensionAuto<BlockquoteOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [bqAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Blockquote/index.js

@@ -0,0 +1,36 @@
+import { chainCommands, wrapIn } from 'prosemirror-commands';
+import { hasParentNodeOfType } from 'prosemirror-utils';
+import { wrappingInputRule } from '../../../utils/inputrules';
+import { withLogAction } from '../../../utils/keymap';
+import { BlockquoteSpecs, blockquoteType } from './BlockquoteSpecs';
+import { joinPrevQuote, liftFromQuote, toggleQuote } from './commands';
+export { blockquote, blockquoteNodeName, blockquoteType } from './const';
+const bqAction = 'quote';
+export const Blockquote = (builder, opts) => {
+    builder.use(BlockquoteSpecs);
+    if (opts === null || opts === void 0 ? void 0 : opts.qouteKey) {
+        const { qouteKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [qouteKey]: withLogAction('blockquote', wrapIn(blockquoteType(schema))),
+        }));
+    }
+    builder.addKeymap(() => ({
+        Backspace: chainCommands(liftFromQuote, joinPrevQuote),
+    }));
+    builder.addInputRules(({ schema }) => ({ rules: [blockQuoteRule(blockquoteType(schema))] }));
+    builder.addAction(bqAction, ({ schema }) => {
+        const bq = blockquoteType(schema);
+        return {
+            isActive: (state) => hasParentNodeOfType(bq)(state.selection),
+            isEnable: toggleQuote,
+            run: toggleQuote,
+        };
+    });
+};
+/**
+ * Given a blockquote node type, returns an input rule that turns `"> "`
+ * at the start of a textblock into a blockquote.
+ */
+function blockQuoteRule(nodeType) {
+    return wrappingInputRule(/^\s*>\s$/, nodeType);
+}

package/build/esm/extensions/markdown/Bold/BoldSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const boldMarkName = "strong";
+export declare const boldType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const BoldSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Bold/BoldSpecs/index.js

@@ -0,0 +1,27 @@
+import { markTypeFactory } from '../../../../utils/schema';
+export const boldMarkName = 'strong';
+export const boldType = markTypeFactory(boldMarkName);
+export const BoldSpecs = (builder) => {
+    builder.addMark(boldMarkName, () => ({
+        spec: {
+            parseDOM: [
+                { tag: 'b' },
+                { tag: 'strong' },
+                {
+                    style: 'font-weight',
+                    getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null,
+                },
+            ],
+            toDOM() {
+                return ['strong'];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: boldMarkName,
+                type: 'mark',
+            },
+        },
+        toMd: { open: '**', close: '**', mixable: true, expelEnclosingWhitespace: true },
+    }));
+};

package/build/esm/extensions/markdown/Bold/index.d.ts

@@ -0,0 +1,16 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { boldMarkName, boldType } from './BoldSpecs';
+/** @deprecated Use `boldMarkName` instead */
+export declare const bold = "strong";
+declare const bAction = "bold";
+export declare type BoldOptions = {
+    boldKey?: string | null;
+};
+export declare const Bold: ExtensionAuto<BoldOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [bAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Bold/index.js

@@ -0,0 +1,25 @@
+import { toggleMark } from 'prosemirror-commands';
+import { createToggleMarkAction } from '../../../utils/actions';
+import { markInputRule } from '../../../utils/inputrules';
+import { withLogAction } from '../../../utils/keymap';
+import { BoldSpecs, boldMarkName, boldType } from './BoldSpecs';
+export { boldMarkName, boldType } from './BoldSpecs';
+/** @deprecated Use `boldMarkName` instead */
+export const bold = boldMarkName;
+const bAction = 'bold';
+export const Bold = (builder, opts) => {
+    builder.use(BoldSpecs);
+    builder.addAction(bAction, ({ schema }) => createToggleMarkAction(boldType(schema)));
+    if (opts === null || opts === void 0 ? void 0 : opts.boldKey) {
+        const { boldKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [boldKey]: withLogAction('bold', toggleMark(boldType(schema))),
+        }));
+    }
+    builder.addInputRules(({ schema }) => ({
+        rules: [
+            markInputRule({ open: '**', close: '**', ignoreBetween: '*' }, boldType(schema)),
+            markInputRule({ open: '__', close: '__', ignoreBetween: '_' }, boldType(schema)),
+        ],
+    }));
+};

package/build/esm/extensions/markdown/Breaks/BreaksSpecs/index.d.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare enum BreakNodeName {
+    HardBreak = "hard_break",
+    SoftBreak = "soft_break"
+}
+export declare const hbType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const sbType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type BreaksSpecsOptions = {
+    /**
+     * @default 'hard'
+     */
+    preferredBreak?: 'hard' | 'soft';
+};
+export declare const BreaksSpecs: ExtensionAuto<BreaksSpecsOptions>;

package/build/esm/extensions/markdown/Breaks/BreaksSpecs/index.js

@@ -0,0 +1,59 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export var BreakNodeName;
+(function (BreakNodeName) {
+    BreakNodeName["HardBreak"] = "hard_break";
+    BreakNodeName["SoftBreak"] = "soft_break";
+})(BreakNodeName || (BreakNodeName = {}));
+export const hbType = nodeTypeFactory(BreakNodeName.HardBreak);
+export const sbType = nodeTypeFactory(BreakNodeName.SoftBreak);
+export const BreaksSpecs = (builder, opts) => {
+    const { preferredBreak = 'hard' } = opts;
+    const parseDOM = [{ tag: 'br' }];
+    builder.addNode(BreakNodeName.HardBreak, () => ({
+        spec: {
+            inline: true,
+            group: 'inline break',
+            marks: '',
+            isBreak: true,
+            selectable: false,
+            parseDOM: preferredBreak === 'hard' ? parseDOM : undefined,
+            toDOM() {
+                return ['br'];
+            },
+        },
+        fromMd: { tokenName: 'hardbreak', tokenSpec: { name: BreakNodeName.HardBreak, type: 'node' } },
+        toMd: (state, node, parent, index) => {
+            for (let i = index + 1; i < parent.childCount; i++) {
+                if (parent.child(i).type !== node.type) {
+                    state.write('\\\n');
+                    return;
+                }
+            }
+        },
+    }));
+    // TODO: should we handle softbreak differently at different md.options.breaks setting?
+    // we can safely convert softbreak into hardbreak,
+    // but in this case non-edited markup will always be changed – a backspash will be added
+    builder.addNode(BreakNodeName.SoftBreak, () => ({
+        spec: {
+            inline: true,
+            group: 'inline break',
+            marks: '',
+            isBreak: true,
+            selectable: false,
+            parseDOM: preferredBreak === 'soft' ? parseDOM : undefined,
+            toDOM() {
+                return ['br'];
+            },
+        },
+        fromMd: { tokenName: 'softbreak', tokenSpec: { name: BreakNodeName.SoftBreak, type: 'node' } },
+        toMd: (state, node, parent, index) => {
+            for (let i = index + 1; i < parent.childCount; i++) {
+                if (parent.child(i).type !== node.type) {
+                    state.write('\n');
+                    return;
+                }
+            }
+        },
+    }));
+};

package/build/esm/extensions/markdown/Breaks/index.d.ts

@@ -0,0 +1,20 @@
+import type { ExtensionAuto } from '../../../core';
+export { BreaksSpecs, BreakNodeName, hbType, sbType } from './BreaksSpecs';
+export declare type BreaksOptions = {
+    /**
+     * This option is used if the 'breaks' parameter is not specified via the context
+     * @default 'hard'
+     */
+    preferredBreak?: 'hard' | 'soft';
+};
+export declare const Breaks: ExtensionAuto<BreaksOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Context {
+            /**
+             * Same as @type {MarkdownIt.Options.breaks}
+             */
+            breaks: boolean;
+        }
+    }
+}

package/build/esm/extensions/markdown/Breaks/index.js

@@ -0,0 +1,61 @@
+import { chainCommands, exitCode } from 'prosemirror-commands';
+import { TextSelection } from 'prosemirror-state';
+import { logger } from '../../../logger';
+import { isMac } from '../../../utils/platform';
+import { isTextSelection } from '../../../utils/selection';
+import { pType } from '../../base/BaseSchema/BaseSchemaSpecs';
+import { BreaksSpecs, hbType, sbType } from './BreaksSpecs';
+export { BreaksSpecs, BreakNodeName, hbType, sbType } from './BreaksSpecs';
+export const Breaks = (builder, opts) => {
+    var _a;
+    let preferredBreak;
+    if (builder.context.has('breaks')) {
+        preferredBreak = builder.context.get('breaks') ? 'soft' : 'hard';
+    }
+    else {
+        preferredBreak = (_a = opts.preferredBreak) !== null && _a !== void 0 ? _a : 'hard';
+        logger.info("[Breaks extension]: Parameter 'breaks' is not defined in context; value from options is used");
+    }
+    builder.use(BreaksSpecs, { preferredBreak });
+    builder.addKeymap(({ schema }) => {
+        const cmd = addBr((preferredBreak === 'soft' ? sbType : hbType)(schema));
+        const keys = {
+            'Shift-Enter': cmd,
+        };
+        if (isMac()) {
+            keys['Ctrl-Enter'] = cmd;
+        }
+        return keys;
+    });
+};
+const addBr = (br) => chainCommands(exitCode, (state, dispatch) => {
+    var _a;
+    const { selection: sel, schema } = state;
+    if (!isTextSelection(sel) ||
+        !sel.empty ||
+        // breaks can only be in the paragraph
+        ((_a = sel.$cursor) === null || _a === void 0 ? void 0 : _a.parent.type) !== pType(schema))
+        return false;
+    if (isBreakNode(sel.$cursor.nodeBefore)) {
+        if (dispatch) {
+            const { $cursor, $cursor: { pos }, } = sel;
+            const from = isBreakNode($cursor.nodeAfter) ? pos + 1 : pos;
+            const posEnd = $cursor.end();
+            const posAfter = $cursor.after();
+            const contentAfter = state.doc.slice(from, posEnd, false).content;
+            let tr = state.tr.insert(posAfter, pType(schema).create(null, contentAfter));
+            tr = tr
+                .setSelection(TextSelection.create(tr.doc, posAfter + 1))
+                .scrollIntoView()
+                .delete(pos, posEnd) // remove content after current pos (it's moved to next para)
+                .delete(pos - 1, pos); // remove break before current pos ($cursor.nodeBefore)
+            dispatch(tr);
+        }
+        return true;
+    }
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+    return true;
+});
+function isBreakNode(node) {
+    return Boolean(node === null || node === void 0 ? void 0 : node.type.spec.isBreak);
+}

package/build/esm/extensions/markdown/Code/CodeSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const codeMarkName = "code";
+export declare const codeType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const CodeSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Code/CodeSpecs/index.js

@@ -0,0 +1,41 @@
+import { markTypeFactory } from '../../../../utils/schema';
+export const codeMarkName = 'code';
+export const codeType = markTypeFactory(codeMarkName);
+export const CodeSpecs = (builder) => {
+    builder.addMark(codeMarkName, () => ({
+        spec: {
+            code: true,
+            parseDOM: [{ tag: 'code' }],
+            toDOM() {
+                return ['code'];
+            },
+        },
+        toMd: {
+            open(_state, _mark, parent, index) {
+                return backticksFor(parent.child(index), -1);
+            },
+            close(_state, _mark, parent, index) {
+                return backticksFor(parent.child(index - 1), 1);
+            },
+            escape: false,
+        },
+        fromMd: {
+            tokenSpec: { name: codeMarkName, type: 'mark', code: true, noCloseToken: true },
+            tokenName: 'code_inline',
+        },
+    }), builder.Priority.Lowest);
+};
+function backticksFor(node, side) {
+    const ticks = /`+/g;
+    let m;
+    let len = 0;
+    if (node.isText)
+        while ((m = ticks.exec(node.text || '')))
+            len = Math.max(len, m[0].length);
+    let result = len > 0 && side > 0 ? ' `' : '`';
+    for (let i = 0; i < len; i++)
+        result += '`';
+    if (len > 0 && side < 0)
+        result += ' ';
+    return result;
+}

package/build/esm/extensions/markdown/Code/code.css

@@ -0,0 +1,24 @@
+@keyframes code_fake_blink {
+  49% {
+    border-color: unset;
+  }
+  50% {
+    border-color: transparent;
+  }
+  99% {
+    border-color: transparent;
+  }
+}
+.ProseMirror.no-cursor {
+  caret-color: transparent;
+}
+
+.ProseMirror-focused .fake-cursor {
+  position: relative;
+  z-index: 1;
+  margin-right: -1px;
+  border-left-width: 1px;
+  border-left-style: solid;
+  animation: code_fake_blink 1s;
+  animation-iteration-count: infinite;
+}

package/build/esm/extensions/markdown/Code/index.d.ts

@@ -0,0 +1,17 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import './code.css';
+export { codeMarkName, codeType } from './CodeSpecs';
+/** @deprecated Use `codeMarkName` instead */
+export declare const code = "code";
+declare const codeAction = "code";
+export declare type CodeOptions = {
+    codeKey?: string | null;
+};
+export declare const Code: ExtensionAuto<CodeOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [codeAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Code/index.js

@@ -0,0 +1,43 @@
+import codemark from 'prosemirror-codemark';
+import { toggleMark } from 'prosemirror-commands';
+import { Plugin } from 'prosemirror-state';
+import { createToggleMarkAction } from '../../../utils/actions';
+import { withLogAction } from '../../../utils/keymap';
+import { CodeSpecs, codeMarkName, codeType } from './CodeSpecs';
+import './code.css';
+export { codeMarkName, codeType } from './CodeSpecs';
+/** @deprecated Use `codeMarkName` instead */
+export const code = codeMarkName;
+const codeAction = 'code';
+export const Code = (builder, opts) => {
+    builder.use(CodeSpecs);
+    builder.addAction(codeAction, ({ schema }) => createToggleMarkAction(codeType(schema)));
+    if (opts === null || opts === void 0 ? void 0 : opts.codeKey) {
+        const { codeKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [codeKey]: withLogAction('code_inline', toggleMark(codeType(schema))),
+        }));
+    }
+    builder
+        // codemark adds inputRule for `code`,
+        // adds fake cursor behaviour when crossing inline_code boundaries,
+        // wrap current selected text to inline_code when '`' was pressed.
+        // See demo: https://curvenote.github.io/prosemirror-codemark/
+        .addPlugin(({ schema }) => codemark({ markType: codeType(schema) }));
+    builder.addPlugin(() => 
+    // apply codemark when typing text between ``
+    new Plugin({
+        props: {
+            handleTextInput: (view, from, to, text) => {
+                var _a, _b, _c, _d;
+                const { selection: { $anchor }, tr, schema, } = view.state;
+                if (((_b = (_a = $anchor.nodeBefore) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.endsWith('`')) &&
+                    ((_d = (_c = $anchor.nodeAfter) === null || _c === void 0 ? void 0 : _c.text) === null || _d === void 0 ? void 0 : _d.startsWith('`'))) {
+                    view.dispatch(tr.replaceRangeWith(from - 1, to + 1, view.state.schema.text(text, [codeType(schema).create()])));
+                    return true;
+                }
+                return false;
+            },
+        },
+    }));
+};

package/build/esm/extensions/markdown/CodeBlock/CodeBlockHighlight/CodeBlockHighlight.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from '@diplodoc/transform';
+import type { ExtensionAuto } from '../../../../core';
+export declare type HighlightLangMap = Options['highlightLangs'];
+export declare type CodeBlockHighlightOptions = {
+    langs?: HighlightLangMap;
+};
+export declare const CodeBlockHighlight: ExtensionAuto<CodeBlockHighlightOptions>;

package/build/esm/extensions/markdown/CodeBlock/CodeBlockHighlight/CodeBlockHighlight.js

@@ -0,0 +1,166 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { findChildrenByType } from 'prosemirror-utils';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { capitalize } from '../../../../lodash';
+import { logger } from '../../../../logger';
+import { codeBlockLangAttr, codeBlockNodeName, codeBlockType } from '../CodeBlockSpecs';
+import { codeLangSelectTooltipViewCreator } from './TooltipPlugin';
+const key = new PluginKey('code_block_highlight');
+export const CodeBlockHighlight = (builder, opts) => {
+    let langs;
+    let lowlight;
+    let hljs;
+    try {
+        hljs = require('highlight.js/lib/core');
+        const low = require('lowlight');
+        const all = low.all;
+        const create = low.createLowlight;
+        langs = Object.assign(Object.assign({}, all), opts.langs);
+        lowlight = create(langs);
+    }
+    catch (e) {
+        logger.info('Skip code_block highlighting');
+        return;
+    }
+    builder.addPlugin(() => {
+        const selectItems = [];
+        const mapping = {};
+        for (const lang of Object.keys(langs)) {
+            const defs = langs[lang](hljs);
+            selectItems.push({
+                value: lang,
+                content: defs.name || capitalize(lang),
+            });
+            if (defs.aliases) {
+                for (const alias of defs.aliases) {
+                    mapping[alias] = lang;
+                }
+            }
+        }
+        // TODO: add TAB key handler
+        // TODO: Remove constant selection of block
+        return new Plugin({
+            key,
+            state: {
+                init: (_, state) => getDecorations(state.doc),
+                apply: (tr, decos, oldState, newState) => {
+                    if (tr.docChanged) {
+                        const oldNodeName = oldState.selection.$head.parent.type.name;
+                        const newNodeName = newState.selection.$head.parent.type.name;
+                        // Apply decorations if:
+                        if (oldNodeName === codeBlockNodeName ||
+                            newNodeName === codeBlockNodeName) {
+                            // selection includes codeblock node,
+                            return getDecorations(tr.doc);
+                        }
+                        else {
+                            const oldNodes = findChildrenByType(oldState.doc, codeBlockType(oldState.schema));
+                            const newNodes = findChildrenByType(newState.doc, codeBlockType(newState.schema));
+                            if (
+                            // OR transaction adds/removes codeblock nodes,
+                            newNodes.length !== oldNodes.length ||
+                                // OR transaction has changes that completely encapsulate a node
+                                // (for example, a transaction that affects the entire document).
+                                // Such transactions can happen during collab syncing via y-prosemirror, for example.
+                                tr.steps.some((step) => {
+                                    return (stepHasFromTo(step) &&
+                                        oldNodes.some((node) => node.pos >= step.from &&
+                                            node.pos + node.node.nodeSize <= step.to));
+                                })) {
+                                return getDecorations(tr.doc);
+                            }
+                        }
+                    }
+                    return decos.map(tr.mapping, tr.doc);
+                },
+            },
+            view: (view) => codeLangSelectTooltipViewCreator(view, selectItems, mapping),
+            props: {
+                decorations: (state) => {
+                    return key.getState(state);
+                },
+                nodeViews: {
+                    [codeBlockNodeName]: (node) => {
+                        let prevLang = node.attrs[codeBlockLangAttr];
+                        const dom = document.createElement('pre');
+                        const contentDOM = document.createElement('code');
+                        contentDOM.classList.add('hljs');
+                        if (prevLang) {
+                            dom.setAttribute(codeBlockLangAttr, prevLang);
+                            contentDOM.classList.add(prevLang);
+                        }
+                        dom.append(contentDOM);
+                        return {
+                            dom,
+                            contentDOM,
+                            update(newNode) {
+                                if (node.type !== newNode.type)
+                                    return false;
+                                const newLang = newNode.attrs[codeBlockLangAttr];
+                                if (prevLang !== newLang) {
+                                    contentDOM.className = 'hljs';
+                                    if (newLang) {
+                                        dom.setAttribute(codeBlockLangAttr, newLang);
+                                        contentDOM.classList.add(newLang);
+                                    }
+                                    else {
+                                        dom.removeAttribute(codeBlockLangAttr);
+                                    }
+                                    prevLang = newLang;
+                                }
+                                return true;
+                            },
+                        };
+                    },
+                },
+            },
+        });
+    });
+    function getDecorations(doc) {
+        const decos = [];
+        for (const { node, pos } of findChildrenByType(doc, codeBlockType(doc.type.schema), true)) {
+            let from = pos + 1;
+            let nodes;
+            const lang = node.attrs[codeBlockLangAttr];
+            if (!lang) {
+                nodes = lowlight.highlightAuto(node.textContent).children;
+            }
+            else if (lowlight.registered(lang)) {
+                nodes = lowlight.highlight(lang, node.textContent).children;
+            }
+            else {
+                continue;
+            }
+            for (const { text, classes } of parseNodes(nodes)) {
+                const to = from + text.length;
+                if (classes.length) {
+                    decos.push(Decoration.inline(from, to, {
+                        class: classes.join(' '),
+                    }));
+                }
+                from = to;
+            }
+        }
+        return DecorationSet.create(doc, decos);
+    }
+};
+function parseNodes(nodes, className = []) {
+    return nodes
+        .map((node) => {
+        var _a;
+        let classes = className;
+        if (node.type === 'element') {
+            classes = classes.concat((_a = node.properties.className) !== null && _a !== void 0 ? _a : []);
+            return parseNodes(node.children, classes);
+        }
+        return {
+            text: node.type === 'comment' || node.type === 'text' ? node.value : '',
+            classes,
+        };
+    })
+        .flat();
+}
+function stepHasFromTo(step) {
+    // @ts-expect-error
+    return typeof step.from === 'number' && typeof step.to === 'number';
+}

package/build/esm/extensions/markdown/CodeBlock/CodeBlockHighlight/TooltipPlugin/TooltipView.css

@@ -0,0 +1,26 @@
+.g-md-code-block-toolbar {
+  margin: 2px 8px;
+}
+
+.g-md-code-tooltip-menu {
+  min-width: 150px;
+  border-radius: 4px;
+}
+
+.g-md-code-block__select-popup {
+  width: 175px;
+  max-height: 200px;
+}
+.g-md-code-block__select-popup .g-select-filter {
+  border-bottom: 1px solid var(--g-color-line-generic);
+}
+.g-md-code-block__select-popup .g-select-filter .g-text-input__content {
+  border: none;
+}
+.g-md-code-block__select-popup .g-md-code-block__select-empty {
+  margin-left: 4px;
+}
+
+.g-md-code-block__select-button {
+  margin: auto 0;
+}

package/build/esm/extensions/markdown/CodeBlock/CodeBlockHighlight/TooltipPlugin/index.d.ts

@@ -0,0 +1,5 @@
+import { SelectOption } from '@gravity-ui/uikit';
+import { EditorView } from 'prosemirror-view';
+import { BaseTooltipPluginView } from '../../../../../plugins/BaseTooltip';
+import './TooltipView.css';
+export declare const codeLangSelectTooltipViewCreator: (view: EditorView, langItems: SelectOption[], mapping?: Record<string, string>) => BaseTooltipPluginView;