@gravity-ui/markdown-editor 13.17.0 → 13.18.0

package/build/esm/table-utils/commands/appendRow.js

@@ -1,35 +1,53 @@
-import { Fragment } from 'prosemirror-model';
-import { findChildren, findParentNodeClosestToPos } from 'prosemirror-utils';
-import { findChildTableRows, isTableBodyNode, isTableNode, isTableRowNode } from '..';
+import { findParentNodeClosestToPos } from 'prosemirror-utils';
+import { isTableNode } from '..';
+import { TableDesc } from '../table-desc';
 export const appendRow = (state, dispatch, _, attrs) => {
-    var _a;
     if (!attrs)
         return false;
-    const { tablePos, rowNumber, direction } = attrs;
-    const tableNode = (_a = findParentNodeClosestToPos(state.doc.resolve(tablePos + 1), isTableNode)) === null || _a === void 0 ? void 0 : _a.node;
-    if (!tableNode)
+    const { tablePos, rowNumber, direction = 'after' } = attrs;
+    const res = findParentNodeClosestToPos(state.doc.resolve(tablePos + 1), isTableNode);
+    if (!res)
         return false;
-    const parentBody = findChildren(tableNode, isTableBodyNode, false).pop();
-    if (!parentBody)
+    const tableNode = res.node;
+    const tableDesc = TableDesc.create(tableNode);
+    if (!tableDesc)
         return false;
-    let parentRow;
-    if (rowNumber !== undefined) {
-        parentRow = findChildTableRows(tableNode)[rowNumber];
+    const rowIndex = rowNumber !== null && rowNumber !== void 0 ? rowNumber : tableDesc.rows - 1; // if rowNumber is not defined, that means last row
+    const isFirstRow = rowIndex === 0;
+    const isLastRow = rowIndex === tableDesc.rows - 1;
+    let pos = -1;
+    if (isFirstRow && direction === 'before')
+        pos = tableDesc.getRelativePosForRow(0).from;
+    if (isLastRow && direction === 'after')
+        pos = tableDesc.getRelativePosForRow(tableDesc.rows - 1).to;
+    if (pos === -1) {
+        if (tableDesc.rows <= rowIndex)
+            return false;
+        if (tableDesc.isSafeRow(rowIndex)) {
+            const rowPos = tableDesc.getRelativePosForRow(rowIndex);
+            if (direction === 'before')
+                pos = rowPos.from;
+            if (direction === 'after')
+                pos = rowPos.to;
+        }
+        else {
+            if (direction === 'before' && tableDesc.isSafeRow(rowIndex - 1))
+                pos = tableDesc.getRelativePosForRow(rowIndex - 1).to;
+            if (direction === 'after' && tableDesc.isSafeRow(rowIndex + 1))
+                pos = tableDesc.getRelativePosForRow(rowIndex + 1).from;
+        }
     }
-    else {
-        parentRow = findChildren(parentBody.node, isTableRowNode, false).pop();
-    }
-    if (!parentRow) {
+    if (pos === -1)
         return false;
-    }
     if (dispatch) {
-        const newCellNodes = [];
-        parentRow.node.forEach((node) => {
-            newCellNodes.push(node.type.createAndFill(node.attrs));
-        });
-        let position = tablePos + parentRow.pos;
-        position += direction === 'before' ? 1 : parentRow.node.nodeSize + 1;
-        dispatch(state.tr.insert(position, parentRow.node.copy(Fragment.from(newCellNodes))));
+        const cells = getNodes(tableDesc.getCellNodeType(), tableDesc.cols);
+        dispatch(state.tr.insert(res.pos + pos, tableDesc.getRowNodeType().create(null, cells)));
     }
     return true;
 };
+function getNodes(type, count) {
+    const nodes = [];
+    for (let i = 0; i < count; i++)
+        nodes.push(type.createAndFill());
+    return nodes;
+}

package/build/esm/table-utils/commands/removeColumn.js

@@ -1,5 +1,5 @@
-import { isTableNode } from '..';
-import { isTableBodyNode, isTableCellNode, isTableRowNode } from '../utils';
+import { TableDesc } from '../table-desc';
+import { isTableNode } from '../utils';
 export const removeColumn = (state, dispatch, _, attrs = {}) => {
     const { tablePos, columnNumber } = attrs;
     if (typeof tablePos !== 'number' || typeof columnNumber !== 'number')
@@ -11,28 +11,26 @@ export const removeColumn = (state, dispatch, _, attrs = {}) => {
     const tableNode = state.doc.nodeAt(tablePos);
     if (!tableNode || tableNode.nodeSize <= 2 || !isTableNode(tableNode))
         return false;
-    const tableBodyNode = tableNode.firstChild;
-    if (!tableBodyNode || tableBodyNode.nodeSize <= 2 || !isTableBodyNode(tableBodyNode))
+    const tableDesc = TableDesc.create(tableNode);
+    if (!tableDesc)
         return false;
-    // there is one column left
-    if (tableBodyNode.firstChild && tableBodyNode.firstChild.childCount < 2)
+    if (!tableDesc ||
+        // there is one column left
+        tableDesc.cols < 2 ||
+        tableDesc.cols <= columnNumber ||
+        !tableDesc.isSafeColumn(columnNumber))
         return false;
     if (dispatch) {
         const { tr } = state;
-        tableBodyNode.forEach((rowNode, rowOffset) => {
-            if (!isTableRowNode(rowNode))
-                return;
-            rowNode.forEach((cellNode, cellOffset, cellIndex) => {
-                if (!isTableCellNode(cellNode))
-                    return;
-                if (cellIndex === columnNumber) {
-                    // table -> tbody -> tr -> td
-                    const from = tablePos + 2 + rowOffset + 1 + cellOffset;
-                    const to = from + cellNode.nodeSize;
-                    tr.delete(tr.mapping.map(from), tr.mapping.map(to));
-                }
-            });
-        });
+        const pos = tableDesc.getRelativePosForColumn(columnNumber);
+        for (const item of pos) {
+            if (item.type === 'real') {
+                let { from, to } = item;
+                from += tablePos;
+                to += tablePos;
+                tr.delete(tr.mapping.map(from), tr.mapping.map(to));
+            }
+        }
         dispatch(tr);
     }
     return true;

package/build/esm/table-utils/commands/removeRow.js

@@ -1,8 +1,8 @@
 import { Fragment } from 'prosemirror-model';
-import { findChildren, findParentNodeClosestToPos } from 'prosemirror-utils';
-import { findChildTableBody, isTableNode, isTableRowNode } from '..';
+import { findParentNodeClosestToPos } from 'prosemirror-utils';
+import { isTableNode } from '..';
 import { trackTransactionMetrics } from '../../core';
-import { findChildTableRows } from '../utils';
+import { TableDesc } from '../table-desc';
 export const removeRow = (state, dispatch, _, attrs = {}) => {
     var _a;
     const { tablePos, rowNumber } = attrs;
@@ -11,16 +11,19 @@ export const removeRow = (state, dispatch, _, attrs = {}) => {
     const tableNode = (_a = findParentNodeClosestToPos(state.doc.resolve(tablePos + 1), isTableNode)) === null || _a === void 0 ? void 0 : _a.node;
     if (!tableNode)
         return false;
-    const parentRows = findChildren(tableNode, isTableRowNode);
-    const parentBody = findChildTableBody(tableNode)[0];
-    const parentRow = parentRows[rowNumber];
-    if (!parentRows.length || !parentBody) {
+    const tableDesc = TableDesc.create(tableNode);
+    if (!tableDesc || rowNumber >= tableDesc.rows)
         return false;
-    }
-    if (findChildTableRows(parentBody.node).length < 2) {
-        // there is one row left
+    if (!tableDesc.isSafeRow(rowNumber))
         return false;
+    if (dispatch) {
+        let { from, to } = tableDesc.getRelativePosForRow(rowNumber);
+        from += tablePos;
+        to += tablePos;
+        dispatch(trackTransactionMetrics(state.tr.replaceWith(from, to, Fragment.empty), 'removeRow', {
+            rows: tableDesc.rows,
+            cols: tableDesc.cols,
+        }));
     }
-    dispatch === null || dispatch === void 0 ? void 0 : dispatch(trackTransactionMetrics(state.tr.replaceWith(tablePos + parentRow.pos, tablePos + parentRow.pos + parentRow.node.nodeSize + 1, Fragment.empty), 'removeRow', { rows: parentRows.length, cols: parentRow.node.childCount }));
     return true;
 };

package/build/esm/table-utils/table-desc.d.ts

@@ -0,0 +1,53 @@
+import type { Node } from 'prosemirror-model';
+declare type TableCellRealDesc = {
+    type: 'real';
+    offset: number;
+    node: Node;
+    colspan?: number;
+    rowspan?: number;
+};
+declare type TableCellVirtualDesc = {
+    type: 'virtual';
+    /** Index of real cell, that prodeced this virtual cell */
+    colspan?: [number, number];
+    /** Index of real cell, that prodeced this virtual cell */
+    rowspan?: [number, number];
+};
+declare type Pos = {
+    from: number;
+    to: number;
+};
+export declare type CellPos = ({
+    type: 'real';
+} & Pos) | {
+    type: 'virtual';
+    closestPos: number;
+};
+declare type TableCellDesc = TableCellRealDesc | TableCellVirtualDesc;
+declare type TableRowDesc = {
+    node: Node;
+    cells: TableCellDesc[];
+    offset: number;
+    colspan?: boolean;
+    rowspan?: boolean;
+};
+export declare class TableDesc {
+    readonly rows: number;
+    readonly cols: number;
+    readonly rowsDesc: readonly TableRowDesc[];
+    readonly baseOffset: number;
+    private static __cache;
+    static create(table: Node): TableDesc | null;
+    private constructor();
+    rowHasVirtualCells(rowIndex: number): boolean;
+    columnHasVirtualCells(columnIndex: number): boolean;
+    isSafeColumn(columnIndex: number): boolean;
+    isSafeRow(rowIndex: number): boolean;
+    getOffsetForRow(rowIndex: number): number;
+    getRelativePosForRow(rowIndex: number): Pos;
+    getRelativePosForCell(rowIndex: number, columnIndex: number): CellPos;
+    getRelativePosForColumn(columnIndex: number): CellPos[];
+    getCellNodeType(): import("prosemirror-model").NodeType;
+    getRowNodeType(): import("prosemirror-model").NodeType;
+}
+export {};

package/build/esm/table-utils/table-desc.js

@@ -0,0 +1,144 @@
+import isNumber from 'is-number';
+import { isTableBodyNode, isTableNode } from './utils';
+export class TableDesc {
+    constructor(
+    /* eslint-disable @typescript-eslint/parameter-properties */
+    rows, cols, rowsDesc, baseOffset) {
+        this.rows = rows;
+        this.cols = cols;
+        this.rowsDesc = rowsDesc;
+        this.baseOffset = baseOffset;
+    }
+    static create(table) {
+        if (this.__cache.has(table))
+            return this.__cache.get(table);
+        if (!isTableNode(table))
+            return null;
+        const tbody = table.lastChild;
+        if (!tbody || !isTableBodyNode(tbody))
+            return null;
+        // table –> tbody -> ...
+        const baseOffset = 2;
+        const rows = [];
+        tbody.forEach((trow, offset) => {
+            rows.push({ node: trow, offset, cells: [] });
+        });
+        tbody.forEach((trow, _1, trowIndex) => {
+            trow.forEach((tcell, offset, tcellRealIndex) => {
+                var _a;
+                const rowDesc = rows[trowIndex];
+                let tcellIndex = tcellRealIndex;
+                while (rowDesc.cells[tcellIndex]) {
+                    tcellIndex++;
+                }
+                const cellDesc = (rowDesc.cells[tcellIndex] = {
+                    type: 'real',
+                    node: tcell,
+                    offset,
+                });
+                const map = [trowIndex, tcellIndex];
+                if (isNumber(tcell.attrs['colspan'])) {
+                    rowDesc.colspan = true;
+                    const colspan = (cellDesc.colspan = parseInt(tcell.attrs['colspan'], 10));
+                    for (let i = 1; i < colspan; i++) {
+                        rowDesc.cells[tcellIndex + i] = {
+                            type: 'virtual',
+                            colspan: map,
+                        };
+                    }
+                }
+                if (isNumber(tcell.attrs['rowspan'])) {
+                    rowDesc.rowspan = true;
+                    const rowspan = (cellDesc.rowspan = parseInt(tcell.attrs['rowspan'], 10));
+                    for (let i = 1; i < rowspan; i++) {
+                        const colspan = (_a = cellDesc.colspan) !== null && _a !== void 0 ? _a : 1;
+                        for (let j = 0; j < colspan; j++)
+                            rows[trowIndex + i].cells[tcellIndex + j] = {
+                                type: 'virtual',
+                                rowspan: map,
+                            };
+                    }
+                }
+            });
+        });
+        const desc = new this(rows.length, rows[0].cells.length, rows, baseOffset);
+        this.__cache.set(table, desc);
+        return desc;
+    }
+    rowHasVirtualCells(rowIndex) {
+        var _a;
+        return (_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.cells.some((cell) => cell.type === 'virtual');
+    }
+    columnHasVirtualCells(columnIndex) {
+        return this.rowsDesc.some((row) => { var _a; return ((_a = row.cells[columnIndex]) === null || _a === void 0 ? void 0 : _a.type) === 'virtual'; });
+    }
+    isSafeColumn(columnIndex) {
+        return this.rowsDesc.every((row) => {
+            var _a;
+            const cell = row.cells[columnIndex];
+            if (cell.type === 'real' && (!cell.colspan || cell.colspan === 1))
+                return true;
+            if (cell.type === 'virtual' && ((_a = cell.rowspan) === null || _a === void 0 ? void 0 : _a[1]) === columnIndex)
+                return true;
+            return false;
+        });
+    }
+    isSafeRow(rowIndex) {
+        var _a;
+        return (_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.cells.every((cell) => {
+            var _a;
+            if (cell.type === 'real' && (!cell.rowspan || cell.rowspan === 1))
+                return true;
+            if (cell.type === 'virtual' && ((_a = cell.colspan) === null || _a === void 0 ? void 0 : _a[0]) === rowIndex)
+                return true;
+            return false;
+        });
+    }
+    getOffsetForRow(rowIndex) {
+        var _a;
+        return this.baseOffset + ((_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.offset);
+    }
+    getRelativePosForRow(rowIndex) {
+        const from = this.getOffsetForRow(rowIndex);
+        const to = from + this.rowsDesc[rowIndex].node.nodeSize;
+        return { from, to };
+    }
+    getRelativePosForCell(rowIndex, columnIndex) {
+        var _a;
+        const cell = (_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.cells[columnIndex];
+        const rowOffset = this.getOffsetForRow(rowIndex);
+        if ((cell === null || cell === void 0 ? void 0 : cell.type) === 'real') {
+            // 1 – open boundary for row node
+            const from = rowOffset + 1 + cell.offset;
+            const to = from + cell.node.nodeSize;
+            return { type: 'real', from, to };
+        }
+        if ((cell === null || cell === void 0 ? void 0 : cell.type) === 'virtual') {
+            let index = columnIndex;
+            while (--index >= 0) {
+                const cell = this.rowsDesc[rowIndex].cells[index];
+                if (cell.type === 'real') {
+                    const closest = rowOffset + 1 + cell.offset + cell.node.nodeSize;
+                    return { type: 'virtual', closestPos: closest };
+                }
+            }
+            return { type: 'virtual', closestPos: rowOffset + 1 };
+        }
+        throw new Error(`Impossible to calculate offset for cell with position [${rowIndex},${columnIndex}]`);
+    }
+    getRelativePosForColumn(columnIndex) {
+        const ranges = [];
+        for (let i = 0; i < this.rows; i++) {
+            ranges.push(this.getRelativePosForCell(i, columnIndex));
+        }
+        return ranges;
+    }
+    getCellNodeType() {
+        const isRealCell = (cell) => cell.type === 'real';
+        return this.rowsDesc[0].cells.find(isRealCell).node.type;
+    }
+    getRowNodeType() {
+        return this.rowsDesc[0].node.type;
+    }
+}
+TableDesc.__cache = new WeakMap();

package/build/esm/table-utils/utils.d.ts

@@ -25,7 +25,7 @@ export declare const findChildTableBody: (node: PmNode) => {
     node: PmNode;
     pos: number;
 }[];
-export declare const getTableDimensions: (node: PmNode | Node) => {
+export declare const getTableDimensions: (node: PmNode) => {
     rows: number;
     cols: number;
 };

package/build/esm/table-utils/utils.js

@@ -1,4 +1,4 @@
-import { Node as PmNode } from 'prosemirror-model';
+import isNumber from 'is-number';
 import { findChildren, findParentNode, findParentNodeClosestToPos, } from 'prosemirror-utils';
 import { isTextSelection } from '../utils/selection';
 import { TableRole } from './const';
@@ -18,17 +18,23 @@ export const findChildTableRows = (node) => findChildren(node, isTableRowNode);
 export const findChildTableCells = (node) => findChildren(node, isTableCellNode);
 export const findChildTableBody = (node) => findChildren(node, isTableBodyNode);
 export const getTableDimensions = (node) => {
-    var _a, _b, _c, _d, _e, _f;
-    let rows, cols;
-    if (node instanceof PmNode) {
-        rows = (_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.childCount;
-        cols = (_c = (_b = node.firstChild) === null || _b === void 0 ? void 0 : _b.firstChild) === null || _c === void 0 ? void 0 : _c.childCount;
-    }
-    else {
-        rows = (_d = node.firstChild) === null || _d === void 0 ? void 0 : _d.childNodes.length;
-        cols = (_f = (_e = node.firstChild) === null || _e === void 0 ? void 0 : _e.firstChild) === null || _f === void 0 ? void 0 : _f.childNodes.length;
-    }
-    return { rows: rows || 1, cols: cols || 1 };
+    let rows = 0, cols = 0;
+    const tbody = node.firstChild;
+    tbody === null || tbody === void 0 ? void 0 : tbody.forEach((trow, _1, trowIndex) => {
+        rows++;
+        if (trowIndex === 0) {
+            trow.forEach((tcell, _2) => {
+                const cellAttrs = tcell.attrs;
+                if (isNumber(cellAttrs['colspan'])) {
+                    cols += parseInt(cellAttrs['colspan'], 10);
+                }
+                else {
+                    cols++;
+                }
+            });
+        }
+    });
+    return { rows, cols };
 };
 export function atEndOfCell(view, dir) {
     if (!isTextSelection(view.state.selection))

package/build/esm/version.js

@@ -1,2 +1,2 @@
 /** During build process, the current version will be injected here */
-export const VERSION = typeof '13.17.0' !== 'undefined' ? '13.17.0' : 'unknown';
+export const VERSION = typeof '13.18.0' !== 'undefined' ? '13.18.0' : 'unknown';

package/build/styles.css

@@ -823,6 +823,44 @@ img.ProseMirror-separator {
   animation: placeholder_blink 1s;
   animation-iteration-count: infinite;
 }
+body :has(.g-md-resizable_resizing) {
+  cursor: col-resize;
+}
+
+.g-md-resizable {
+  position: relative;
+}
+.g-md-resizable_resizing .g-md-resizable__resizer-wrapper, .g-md-resizable_hover .g-md-resizable__resizer-wrapper {
+  position: absolute;
+  z-index: 1;
+  top: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: 20px;
+  height: 100%;
+  cursor: col-resize;
+  pointer-events: auto;
+}
+.g-md-resizable_resizing .g-md-resizable__resizer-wrapper_left, .g-md-resizable_hover .g-md-resizable__resizer-wrapper_left {
+  left: 0;
+}
+.g-md-resizable_resizing .g-md-resizable__resizer-wrapper_right, .g-md-resizable_hover .g-md-resizable__resizer-wrapper_right {
+  right: 0;
+}
+.g-md-resizable__resizer {
+  opacity: 0;
+}
+.g-md-resizable_resizing .g-md-resizable__resizer, .g-md-resizable_hover .g-md-resizable__resizer {
+  box-sizing: content-box;
+  width: 4px;
+  height: 50px;
+  max-height: 50%;
+  opacity: 1;
+  border-radius: 6px;
+  background: rgba(127, 127, 127, 0.8);
+  transition: opacity 300ms ease-in 0s;
+}
 .g-md-editor.ProseMirror-focused .pm-node-selected {
   box-shadow: var(--g-color-text-info) 0 0 0 1px;
 }
@@ -1204,6 +1242,130 @@ img.ProseMirror-separator {
   line-height: var(--g-text-body-1-line-height);
   font-weight: var(--g-text-body-font-weight);
 }
+.g-md-gpt-dialog-error-screen__content {
+  display: flex;
+  align-items: center;
+  margin-bottom: var(--g-spacing-2);
+}
+.g-md-gpt-dialog-error-screen__icon {
+  color: var(--g-color-base-danger-heavy);
+}
+.g-md-gpt-dialog-error-screen__text {
+  flex: auto;
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog-error-screen__buttons {
+  display: flex;
+  align-items: center;
+  gap: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__header-top {
+  display: flex;
+  align-items: center;
+}
+.g-md-gpt-dialog__custom-prompt-input {
+  margin-right: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__custom-prompt-input .g-text-input__control {
+  font-size: var(--g-text-body-2-font-size);
+}
+.g-md-gpt-dialog__header-bottom {
+  margin-top: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__custom-prompt {
+  display: flex;
+  flex: auto;
+  align-items: center;
+}
+.g-md-gpt-dialog__alone-presets-text {
+  margin-right: var(--g-spacing-8);
+}
+.g-md-gpt-dialog__alone-presets {
+  display: flex;
+  flex: auto;
+  align-items: center;
+  width: 100%;
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog__alone-presets .g-md-gpt-dialog-preset-list {
+  flex: auto;
+}
+.g-md-gpt-dialog__answer-title {
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog__gpt-icon {
+  margin-right: var(--g-spacing-1);
+}
+.g-md-gpt-dialog__try-again-button {
+  margin-right: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__body {
+  margin: var(--g-spacing-2) calc(-1 * var(--g-spacing-3));
+  padding: var(--g-spacing-4) var(--g-spacing-3);
+  border-top: 1px solid var(--g-color-line-generic);
+}
+.g-md-gpt-dialog__answer {
+  overflow: auto;
+  max-height: 300px;
+}
+.g-md-gpt-dialog__answer-actions {
+  display: flex;
+  align-items: center;
+}
+.g-md-gpt-dialog__feedback-message {
+  margin-left: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__like-button {
+  margin-right: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__close-button {
+  margin-right: var(--g-spacing-2);
+  margin-left: auto;
+}
+.g-md-gpt-dialog__footer {
+  display: flex;
+  align-items: center;
+  margin-top: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__description-alert {
+  min-height: 34px;
+  margin-top: var(--g-spacing-3);
+  padding: var(--g-spacing-1) var(--g-spacing-2);
+}
+.icon-refuge {
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+}
+.icon-refuge_inline {
+  display: inline-flex;
+}
+.g-md-gpt-dialog-preset-list__preset + .g-md-gpt-dialog-preset-list__preset {
+  margin-left: var(--g-spacing-2);
+}
+.g-md-gpt-dialog-preset-list__more-button-wrapper {
+  margin-left: var(--g-spacing-2);
+}
+.g-md-gpt-widget-deco {
+  background-color: var(--g-color-base-info-light-hover);
+}
+
+.g-md-gpt-popup {
+  --layer-navigation-bar: 900;
+  pointer-events: initial;
+}
+.g-md-gpt-popup[class] {
+  border-radius: var(--g-spacing-2);
+}
+.g-md-gpt-popup__content {
+  width: 720px;
+  padding: var(--g-spacing-3);
+  pointer-events: all;
+  box-shadow: -8px 2px 16px -4px var(--g-color-private-purple-150), 8px 2px 16px -4px var(--g-color-private-blue-150);
+}
 .g-md-image-skeleton {
   vertical-align: middle;
 }
@@ -1387,10 +1549,38 @@ img.ProseMirror-separator {
 .table-cell-floating-icon {
   transform: rotate(90deg);
 }
+.g-md-gpt-dialog-loading-screen__header {
+  display: flex;
+  align-items: center;
+  margin-bottom: 8px;
+}
+.g-md-gpt-dialog-loading-screen__icon {
+  margin-right: 4px;
+}
+.g-md-gpt-dialog-loading-screen__text {
+  margin-right: 8px;
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog-loading-screen__skeleton-small-button {
+  width: 90px;
+  height: 28px;
+  margin-right: 8px;
+}
+.g-md-gpt-dialog-loading-screen__skeleton-medium-button {
+  width: 120px;
+  height: 28px;
+}
 .g-md-img-size-node-view__wrapper {
   position: relative;
   display: inline-block;
 }
+.g-md-img-settings-button {
+  position: absolute;
+  z-index: 2;
+  top: 3px;
+  right: 3px;
+}
 .yfm .yfm-note {
   max-width: 1296px;
   margin: 20px 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/markdown-editor",
-  "version": "13.17.0",
+  "version": "13.18.0",
   "description": "Markdown wysiwyg and markup editor",
   "license": "MIT",
   "repository": {
@@ -195,6 +195,7 @@
     "prosemirror-utils": "1.2.0",
     "prosemirror-view": "1.33.6",
     "react-error-boundary": "^3.1.4",
+    "react-hotkeys-hook": "4.5.0",
     "react-use": "^17.3.2",
     "tslib": "^2.3.1"
   },
@@ -278,7 +279,7 @@
     "@diplodoc/html-extension": "2.1.0",
     "@diplodoc/latex-extension": "^1.0.3",
     "@diplodoc/mermaid-extension": "^1.0.0",
-    "@diplodoc/transform": "^4.5.0",
+    "@diplodoc/transform": ">=4.5.0 <4.19.0",
     "@gravity-ui/components": "^3.0.0",
     "@gravity-ui/uikit": "^6.11.0",
     "highlight.js": "^11.8.0",