@gravity-ui/markdown-editor 13.0.0

package/build/cjs/markup/codemirror/gravity.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gravityTheme = exports.gravityHighlightStyle = void 0;
+const language_1 = require("@codemirror/language");
+const view_1 = require("@codemirror/view");
+const highlight_1 = require("@lezer/highlight");
+const yfm_1 = require("./yfm");
+exports.gravityHighlightStyle = language_1.HighlightStyle.define(language_1.defaultHighlightStyle.specs.concat({ tag: highlight_1.tags.meta, color: 'var(--g-color-text-hint)' }, { tag: highlight_1.tags.link, color: 'var(--g-color-text-link)' }, { tag: highlight_1.tags.url, color: 'var(--g-color-text-link-hover)' }, { tag: highlight_1.tags.contentSeparator, color: 'var(--g-color-text-secondary)' }, { tag: [highlight_1.tags.string, highlight_1.tags.deleted], color: 'var(--g-color-text-danger)' }, { tag: highlight_1.tags.escape, color: 'var(--g-color-text-danger-heavy)' }, { tag: highlight_1.tags.typeName, color: 'var(--g-color-text-positive-heavy)' }, { tag: highlight_1.tags.atom, color: 'var(--g-color-text-info-heavy)' }, { tag: highlight_1.tags.labelName, color: 'var(--g-color-text-complementary)' }, { tag: highlight_1.tags.heading, fontWeight: 'bold' }, 
+// custom tags
+{ tag: yfm_1.customTags.underline, textDecoration: 'underline' }, { tag: yfm_1.customTags.monospace, fontFamily: 'monospace' }, { tag: yfm_1.customTags.marked, color: 'marktext', backgroundColor: 'mark' }));
+exports.gravityTheme = view_1.EditorView.baseTheme({
+    '&': {
+        overflow: 'hidden',
+        height: '100%',
+    },
+    '&.cm-focused': {
+        outline: 'none',
+    },
+    '.cm-placeholder': {
+        color: 'var(--g-color-text-secondary)',
+    },
+    '.cm-content': {
+        color: 'var(--g-color-text-primary)',
+        caretColor: 'currentColor',
+        fontSize: 'var(--g-text-code-2-font-size)',
+        fontWeight: 'var(--g-text-code-font-weight)',
+        fontFamily: 'var(--g-font-family-monospace)',
+        lineHeight: 'var(--g-text-code-2-line-height)',
+    },
+    '&.cm-focused .cm-cursor': {
+        borderLeftColor: 'currentColor',
+    },
+    '&.cm-focused .cm-selectionBackground, &.cm-focused ::selection': {
+        background: 'var(--g-color-base-misc-medium)',
+    },
+});

package/build/cjs/markup/codemirror/index.d.ts

@@ -0,0 +1,4 @@
+export type { CreateCodemirrorParams } from './create';
+export { createCodemirror } from './create';
+export { ReactRendererFacet } from './react-facet';
+export { getImageDimensions, IMG_MAX_HEIGHT } from './files-upload-plugin';

package/build/cjs/markup/codemirror/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMG_MAX_HEIGHT = exports.getImageDimensions = exports.ReactRendererFacet = exports.createCodemirror = void 0;
+var create_1 = require("./create");
+Object.defineProperty(exports, "createCodemirror", { enumerable: true, get: function () { return create_1.createCodemirror; } });
+var react_facet_1 = require("./react-facet");
+Object.defineProperty(exports, "ReactRendererFacet", { enumerable: true, get: function () { return react_facet_1.ReactRendererFacet; } });
+var files_upload_plugin_1 = require("./files-upload-plugin");
+Object.defineProperty(exports, "getImageDimensions", { enumerable: true, get: function () { return files_upload_plugin_1.getImageDimensions; } });
+Object.defineProperty(exports, "IMG_MAX_HEIGHT", { enumerable: true, get: function () { return files_upload_plugin_1.IMG_MAX_HEIGHT; } });

package/build/cjs/markup/codemirror/pairing-chars.d.ts

@@ -0,0 +1 @@
+export declare const PairingCharactersExtension: import("@codemirror/state").Extension;

package/build/cjs/markup/codemirror/pairing-chars.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairingCharactersExtension = void 0;
+const state_1 = require("@codemirror/state");
+const view_1 = require("@codemirror/view");
+const PAIRING_CHARS = new Map([
+    ['(', ')'],
+    ['{', '}'],
+    ['[', ']'],
+    ['<', '>'],
+    ['*', '*'],
+    ['~', '~'],
+    ['"', '"'],
+    ["'", "'"],
+    ['`', '`'],
+]);
+exports.PairingCharactersExtension = view_1.EditorView.inputHandler.of((view, _1, _2, text) => {
+    if (!PAIRING_CHARS.has(text))
+        return false;
+    const tr = view.state.changeByRange((range) => {
+        const changes = [{ from: range.from, insert: text }];
+        if (!range.empty)
+            changes.push({ from: range.to, insert: PAIRING_CHARS.get(text) });
+        const changeSet = state_1.ChangeSet.of(changes, view.state.doc.length);
+        return { changes: changeSet, range: range.map(changeSet, range.empty ? 1 : 0) };
+    });
+    view.dispatch(tr, { scrollIntoView: true });
+    return true;
+});

package/build/cjs/markup/codemirror/react-facet.d.ts

@@ -0,0 +1,3 @@
+import { Facet } from '@codemirror/state';
+import type { ReactRenderStorage } from '../../extensions';
+export declare const ReactRendererFacet: Facet<ReactRenderStorage, ReactRenderStorage>;

package/build/cjs/markup/codemirror/react-facet.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactRendererFacet = void 0;
+const state_1 = require("@codemirror/state");
+exports.ReactRendererFacet = state_1.Facet.define({
+    combine: (value) => value[0],
+    static: true,
+});

package/build/cjs/markup/codemirror/yfm.d.ts

@@ -0,0 +1,18 @@
+import { Completion, snippet } from '@codemirror/autocomplete';
+import type { Extension } from '@codemirror/state';
+import { Tag } from '@lezer/highlight';
+export declare const customTags: {
+    underline: Tag;
+    monospace: Tag;
+    marked: Tag;
+};
+export declare type YfmNoteType = 'info' | 'tip' | 'warning' | 'alert';
+export declare const yfmNoteTypes: readonly YfmNoteType[];
+export declare const yfmNoteSnippetTemplate: (type: YfmNoteType) => "{% note info %}\n\n#{}\n\n{% endnote %}\n\n" | "{% note alert %}\n\n#{}\n\n{% endnote %}\n\n" | "{% note tip %}\n\n#{}\n\n{% endnote %}\n\n" | "{% note warning %}\n\n#{}\n\n{% endnote %}\n\n";
+export declare const yfmNoteSnippets: Record<YfmNoteType, ReturnType<typeof snippet>>;
+export declare const yfmCutSnippetTemplate = "{% cut \"#{title}\" %}\n\n#{}\n\n{% endcut %}\n\n";
+export declare const yfmCutSnippet: (editor: {
+    state: import("@codemirror/state").EditorState;
+    dispatch: (tr: import("@codemirror/state").Transaction) => void;
+}, completion: Completion | null, from: number, to: number) => void;
+export declare function yfmLang(): Extension;

package/build/cjs/markup/codemirror/yfm.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yfmLang = exports.yfmCutSnippet = exports.yfmCutSnippetTemplate = exports.yfmNoteSnippets = exports.yfmNoteSnippetTemplate = exports.yfmNoteTypes = exports.customTags = void 0;
+const autocomplete_1 = require("@codemirror/autocomplete");
+const lang_markdown_1 = require("@codemirror/lang-markdown");
+const highlight_1 = require("@lezer/highlight");
+const lodash_1 = require("../../lodash");
+exports.customTags = {
+    underline: highlight_1.Tag.define(),
+    monospace: highlight_1.Tag.define(),
+    marked: highlight_1.Tag.define(),
+};
+function mdInlineFactory({ name, char, tag, }) {
+    const NodeName = name;
+    const MarkName = `${name}Mark`;
+    const Delim = { resolve: NodeName, mark: MarkName };
+    return {
+        defineNodes: [
+            { name: NodeName, style: { [`${NodeName}/...`]: tag } },
+            { name: MarkName, style: highlight_1.tags.processingInstruction },
+        ],
+        parseInline: [
+            {
+                name,
+                parse(cx, next, pos) {
+                    if (next !== char || cx.char(pos + 1) !== char || cx.char(pos + 2) === char)
+                        return -1;
+                    return cx.addDelimiter(Delim, pos, pos + 2, true, true);
+                },
+                after: 'Emphasis',
+            },
+        ],
+    };
+}
+const UnderlineExtension = mdInlineFactory({
+    name: 'Underline',
+    char: '+'.charCodeAt(0),
+    tag: exports.customTags.underline,
+});
+const MonospaceExtension = mdInlineFactory({
+    name: 'Monospace',
+    char: '#'.charCodeAt(0),
+    tag: exports.customTags.monospace,
+});
+const MarkedExtension = mdInlineFactory({
+    name: 'Marked',
+    char: '='.charCodeAt(0),
+    tag: exports.customTags.marked,
+});
+exports.yfmNoteTypes = ['info', 'tip', 'warning', 'alert'];
+const yfmNoteSnippetTemplate = (type) => `{% note ${type} %}\n\n#{}\n\n{% endnote %}\n\n`;
+exports.yfmNoteSnippetTemplate = yfmNoteSnippetTemplate;
+exports.yfmNoteSnippets = {
+    info: (0, autocomplete_1.snippet)((0, exports.yfmNoteSnippetTemplate)('info')),
+    tip: (0, autocomplete_1.snippet)((0, exports.yfmNoteSnippetTemplate)('tip')),
+    warning: (0, autocomplete_1.snippet)((0, exports.yfmNoteSnippetTemplate)('warning')),
+    alert: (0, autocomplete_1.snippet)((0, exports.yfmNoteSnippetTemplate)('alert')),
+};
+exports.yfmCutSnippetTemplate = '{% cut "#{title}" %}\n\n#{}\n\n{% endcut %}\n\n';
+exports.yfmCutSnippet = (0, autocomplete_1.snippet)(exports.yfmCutSnippetTemplate);
+function yfmLang() {
+    const mdSupport = (0, lang_markdown_1.markdown)({
+        // defaultCodeLanguage: markdownLanguage,
+        base: lang_markdown_1.markdownLanguage,
+        addKeymap: true,
+        completeHTMLTags: false,
+        extensions: [UnderlineExtension, MonospaceExtension, MarkedExtension],
+    });
+    const mdAutocomplete = {
+        autocomplete: (context) => {
+            // TODO: add more actions and re-enable
+            // let word = context.matchBefore(/\/.*/);
+            // if (word) {
+            //     return {
+            //         from: word.from,
+            //         options: [
+            //             ...yfmNoteTypes.map<Completion>((type, index) => ({
+            //                 label: `/yfm note ${type}`,
+            //                 displayLabel: `YFM Note ${capitalize(type)}`,
+            //                 type: 'text',
+            //                 apply: yfmNoteSnippets[type],
+            //                 boost: -index,
+            //             })),
+            //             {
+            //                 label: '/yfm cut',
+            //                 displayLabel: 'YFM Cut',
+            //                 type: 'text',
+            //                 apply: yfmCutSnippet,
+            //             },
+            //         ],
+            //     };
+            // }
+            const word = context.matchBefore(/^.*/);
+            if (word === null || word === void 0 ? void 0 : word.text.startsWith('{%')) {
+                return {
+                    from: word.from,
+                    options: [
+                        ...exports.yfmNoteTypes.map((type, index) => ({
+                            label: `{% note ${type}`,
+                            displayLabel: (0, lodash_1.capitalize)(type),
+                            type: 'text',
+                            section: 'YFM Note',
+                            apply: exports.yfmNoteSnippets[type],
+                            boost: -index,
+                        })),
+                        {
+                            label: '{% cut',
+                            displayLabel: 'YFM Cut',
+                            type: 'text',
+                            apply: exports.yfmCutSnippet,
+                        },
+                    ],
+                };
+            }
+            return null;
+        },
+    };
+    return [mdSupport, mdSupport.language.data.of(mdAutocomplete)];
+}
+exports.yfmLang = yfmLang;

package/build/cjs/markup/commands/blocks.d.ts

@@ -0,0 +1,5 @@
+import type { StateCommand } from '@codemirror/state';
+export declare const wrapToBlockquote: StateCommand;
+export declare const wrapToCheckbox: StateCommand;
+export declare const insertHRule: StateCommand;
+export declare const insertMermaidDiagram: StateCommand;

package/build/cjs/markup/commands/blocks.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertMermaidDiagram = exports.insertHRule = exports.wrapToCheckbox = exports.wrapToBlockquote = void 0;
+const helpers_1 = require("./helpers");
+exports.wrapToBlockquote = (0, helpers_1.wrapPerLine)({ beforeText: '> ', skipEmptyLine: false });
+exports.wrapToCheckbox = (0, helpers_1.wrapPerLine)({ beforeText: '[ ] ' });
+const insertHRule = ({ state, dispatch }) => {
+    const hrMarkup = '---';
+    const tr = (0, helpers_1.replaceOrInsertAfter)(state, hrMarkup);
+    dispatch(state.update(tr));
+    return true;
+};
+exports.insertHRule = insertHRule;
+const insertMermaidDiagram = ({ state, dispatch }) => {
+    const markup = `\`\`\`mermaid
+sequenceDiagram
+    Alice->>Bob: Hi Bob
+    Bob->>Alice: Hi Alice
+\`\`\``;
+    const tr = (0, helpers_1.replaceOrInsertAfter)(state, markup);
+    dispatch(state.update(tr));
+    return true;
+};
+exports.insertMermaidDiagram = insertMermaidDiagram;

package/build/cjs/markup/commands/code.d.ts

@@ -0,0 +1,3 @@
+import { StateCommand } from '@codemirror/state';
+export declare const wrapToCodeBlock: StateCommand;
+export declare const wrapToInlineCode: StateCommand;

package/build/cjs/markup/commands/code.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapToInlineCode = exports.wrapToCodeBlock = void 0;
+const state_1 = require("@codemirror/state");
+const helpers_1 = require("./helpers");
+exports.wrapToCodeBlock = (0, helpers_1.wrapToBlock)(({ lineBreak }) => '```' + lineBreak, ({ lineBreak }) => lineBreak + '```');
+const wrapToInlineCode = ({ state, dispatch }) => {
+    const tr = state.changeByRange((range) => {
+        var _a;
+        const content = state.sliceDoc(range.from, range.to);
+        const hasBacktick = content.includes('`');
+        const markup = hasBacktick ? '``' : '`';
+        const before = `${markup}${content.startsWith('`') ? ' ' : ''}`;
+        const after = `${content.endsWith('`') ? ' ' : ''}${markup}`;
+        const changeSpec = [
+            { from: range.from, insert: before },
+            { from: range.to, insert: after },
+        ];
+        const changes = state.changes(changeSpec);
+        return {
+            changes,
+            range: range.empty
+                ? state_1.EditorSelection.range(range.anchor + 1, range.head + 1, range.goalColumn, (_a = range.bidiLevel) !== null && _a !== void 0 ? _a : undefined)
+                : range.map(changes),
+        };
+    });
+    dispatch(state.update(tr));
+    return true;
+};
+exports.wrapToInlineCode = wrapToInlineCode;

package/build/cjs/markup/commands/heading.d.ts

@@ -0,0 +1,7 @@
+import { StateCommand } from '@codemirror/state';
+export declare const toH1: StateCommand;
+export declare const toH2: StateCommand;
+export declare const toH3: StateCommand;
+export declare const toH4: StateCommand;
+export declare const toH5: StateCommand;
+export declare const toH6: StateCommand;

package/build/cjs/markup/commands/heading.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toH6 = exports.toH5 = exports.toH4 = exports.toH3 = exports.toH2 = exports.toH1 = void 0;
+const state_1 = require("@codemirror/state");
+exports.toH1 = toHeading(1);
+exports.toH2 = toHeading(2);
+exports.toH3 = toHeading(3);
+exports.toH4 = toHeading(4);
+exports.toH5 = toHeading(5);
+exports.toH6 = toHeading(6);
+function toHeading(level) {
+    const re = /^\s*#*\s*/;
+    const str = Array(level).fill('#').join('') + ' ';
+    return ({ state, dispatch }) => {
+        const trSpec = state.changeByRange((range) => {
+            var _a, _b, _c;
+            const lineFrom = state.doc.lineAt(range.from);
+            const lineTo = state.doc.lineAt(range.to);
+            // cursor in empty line
+            if (lineFrom.number === lineTo.number && lineFrom.length === 0) {
+                return {
+                    changes: [{ from: lineFrom.from, insert: str }],
+                    // move cursor to end of inserted string with sharps (#)
+                    range: state_1.EditorSelection.range(range.anchor + str.length, range.head + str.length, range.goalColumn, (_a = range.bidiLevel) !== null && _a !== void 0 ? _a : undefined),
+                };
+            }
+            // multiline selection
+            const changes = [];
+            for (let i = lineFrom.number; i <= lineTo.number; i++) {
+                const line = state.doc.line(i);
+                // ignore empty line in multiline selection
+                if (line.length === 0 && !range.empty)
+                    continue;
+                // replace sharps (#) at start of line
+                const replacedLength = (_c = (_b = re.exec(line.text)) === null || _b === void 0 ? void 0 : _b[0].length) !== null && _c !== void 0 ? _c : 0;
+                changes.push({ from: line.from, to: line.from + replacedLength, insert: str });
+            }
+            const changeSet = state.changes(changes);
+            return {
+                changes: changeSet,
+                range: range.map(changeSet),
+            };
+        });
+        dispatch(state.update(trSpec));
+        return true;
+    };
+}

package/build/cjs/markup/commands/helpers.d.ts

@@ -0,0 +1,28 @@
+import { EditorState, Line, SelectionRange, StateCommand, Text, TransactionSpec } from '@codemirror/state';
+export declare function getBlockExtraLineBreaks(state: EditorState, { from: fromLine, to: toLine }: {
+    from: Line;
+    to: Line;
+}): {
+    before: number;
+    after: number;
+};
+export declare function replaceOrInsertAfter(state: EditorState, markup: string): TransactionSpec;
+export declare const wrapToBlock: (before: string | ((arg: Pick<EditorState, 'lineBreak'>) => string), after: string | ((arg: Pick<EditorState, 'lineBreak'>) => string), perLine?: {
+    before: string | ((arg: Pick<EditorState, 'lineBreak'>) => string);
+    after: string | ((arg: Pick<EditorState, 'lineBreak'>) => string);
+    /** @default false */
+    skipEmptyLine?: boolean | undefined;
+} | undefined) => StateCommand;
+export declare function inlineWrapTo(before: string, after?: string): StateCommand;
+export declare function toggleInlineMarkupFactory(markup: string | {
+    before: string;
+    after?: string;
+}): StateCommand;
+declare type WrapPerLineOptions = {
+    beforeText: string;
+    afterText?: string;
+    skipEmptyLine?: boolean;
+};
+export declare const wrapPerLine: ({ beforeText, skipEmptyLine }: WrapPerLineOptions) => StateCommand;
+export declare function iterateOverRangeLines(doc: Text, range: SelectionRange, fn: (line: Line) => void): void;
+export {};

package/build/cjs/markup/commands/helpers.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateOverRangeLines = exports.wrapPerLine = exports.toggleInlineMarkupFactory = exports.inlineWrapTo = exports.wrapToBlock = exports.replaceOrInsertAfter = exports.getBlockExtraLineBreaks = void 0;
+const state_1 = require("@codemirror/state");
+function getBlockExtraLineBreaks(state, { from: fromLine, to: toLine }) {
+    let lineBreaksBefore = 0;
+    if (fromLine.number === 1 || state.doc.line(fromLine.number - 1).length === 0)
+        lineBreaksBefore = 0;
+    else
+        lineBreaksBefore = 1;
+    let lineBreaksAfter = 0;
+    if (toLine.number === state.doc.lines || state.doc.line(fromLine.number + 1).length === 0)
+        lineBreaksAfter = 0;
+    else
+        lineBreaksAfter = 1;
+    return { before: lineBreaksBefore, after: lineBreaksAfter };
+}
+exports.getBlockExtraLineBreaks = getBlockExtraLineBreaks;
+function replaceOrInsertAfter(state, markup) {
+    const selrange = state.selection.main;
+    if (isFullLinesSelection(state.doc, selrange)) {
+        const extraBreaks = getBlockExtraLineBreaks(state, {
+            from: state.doc.lineAt(selrange.from),
+            to: state.doc.lineAt(selrange.to),
+        });
+        return state.replaceSelection(state.lineBreak.repeat(extraBreaks.before) +
+            markup +
+            state.lineBreak.repeat(extraBreaks.after));
+    }
+    else {
+        const insert = state.lineBreak.repeat(2) + markup + state.lineBreak.repeat(2);
+        const from = state.doc.lineAt(selrange.to).to;
+        const selAnchor = from + insert.length - 2;
+        return { changes: { from, insert }, selection: { anchor: selAnchor } };
+    }
+}
+exports.replaceOrInsertAfter = replaceOrInsertAfter;
+function isFullLinesSelection(doc, range) {
+    const fromLine = doc.lineAt(range.from);
+    const toLine = doc.lineAt(range.to);
+    return range.from <= fromLine.from && range.to >= toLine.to;
+}
+const wrapToBlock = (before, after, perLine) => {
+    return ({ state, dispatch }) => {
+        const beforeText = typeof before === 'function' ? before(state) : before;
+        const afterText = typeof after === 'function' ? after(state) : after;
+        const selrange = state.selection.main;
+        const fromLine = state.doc.lineAt(selrange.from);
+        const toLine = state.doc.lineAt(selrange.to);
+        const extraBreaks = getBlockExtraLineBreaks(state, { from: fromLine, to: toLine });
+        const beforeInsertion = state.lineBreak.repeat(extraBreaks.before) + beforeText;
+        const afterInsertion = afterText + state.lineBreak.repeat(extraBreaks.after);
+        const changeSpec = [{ from: fromLine.from, insert: beforeInsertion }];
+        const isEmptyLine = fromLine.number === toLine.number && fromLine.length === 0;
+        let cursorShift = selrange.head + beforeInsertion.length;
+        if (perLine) {
+            const lineBeforeText = typeof perLine.before === 'function' ? perLine.before(state) : perLine.before;
+            const lineAfterText = typeof perLine.after === 'function' ? perLine.after(state) : perLine.after;
+            iterateOverRangeLines(state.doc, selrange, (line) => {
+                if (perLine.skipEmptyLine && line.length === 0)
+                    return;
+                if (lineBeforeText) {
+                    changeSpec.push({ from: line.from, insert: lineBeforeText });
+                    if (isEmptyLine)
+                        cursorShift += lineBeforeText.length;
+                }
+                if (lineAfterText)
+                    changeSpec.push({ from: line.to, insert: lineAfterText });
+            });
+        }
+        changeSpec.push({ from: toLine.to, insert: afterInsertion });
+        const changes = state.changes(changeSpec);
+        dispatch(state.update({
+            changes,
+            selection: isEmptyLine
+                ? state_1.EditorSelection.single(cursorShift)
+                : state.selection.map(changes),
+        }));
+        return true;
+    };
+};
+exports.wrapToBlock = wrapToBlock;
+function inlineWrapTo(before, after = before) {
+    return ({ state, dispatch }) => {
+        const trSpec = state.changeByRange((range) => {
+            var _a;
+            const changes = state.changes([
+                { from: range.from, insert: before },
+                { from: range.to, insert: after },
+            ]);
+            return {
+                changes,
+                range: range.empty
+                    ? state_1.EditorSelection.range(range.anchor + before.length, range.head + before.length, range.goalColumn, (_a = range.bidiLevel) !== null && _a !== void 0 ? _a : undefined)
+                    : range.map(changes),
+            };
+        });
+        dispatch(state.update(trSpec));
+        return true;
+    };
+}
+exports.inlineWrapTo = inlineWrapTo;
+function toggleInlineMarkupFactory(markup) {
+    var _a;
+    const [before, after] = typeof markup === 'string'
+        ? [markup, markup]
+        : [markup.before, (_a = markup.after) !== null && _a !== void 0 ? _a : markup.before];
+    const beforeLength = before.length;
+    const afterLength = after.length;
+    return ({ state, dispatch }) => {
+        const tr = state.changeByRange((range) => {
+            var _a;
+            const hasMarkupBefore = state.sliceDoc(range.from - beforeLength, range.from) === before;
+            const hasMarkupAfter = state.sliceDoc(range.to, range.to + afterLength) === after;
+            const changeSpec = [];
+            if (hasMarkupBefore && hasMarkupAfter) {
+                changeSpec.push({ from: range.from - beforeLength, to: range.from, insert: '' }, { from: range.to, to: range.to + afterLength, insert: '' });
+            }
+            else {
+                if (!hasMarkupBefore) {
+                    changeSpec.push({
+                        from: range.from,
+                        insert: before,
+                    });
+                }
+                if (!hasMarkupAfter) {
+                    changeSpec.push({
+                        from: range.to,
+                        insert: after,
+                    });
+                }
+            }
+            const changes = state.changes(changeSpec);
+            return {
+                changes,
+                range: range.empty && !hasMarkupBefore
+                    ? state_1.EditorSelection.range(range.anchor + beforeLength, range.head + beforeLength, range.goalColumn, (_a = range.bidiLevel) !== null && _a !== void 0 ? _a : undefined)
+                    : range.map(changes),
+            };
+        });
+        tr.scrollIntoView = true;
+        dispatch(state.update(tr));
+        return true;
+    };
+}
+exports.toggleInlineMarkupFactory = toggleInlineMarkupFactory;
+const wrapPerLine = ({ beforeText: before, skipEmptyLine = true }) => ({ state, dispatch }) => {
+    const tr = state.changeByRange((range) => {
+        const changes = [];
+        const isSingleEmptyLine = range.anchor === range.head && state.doc.lineAt(range.head).length === 0;
+        if (isSingleEmptyLine) {
+            changes.push({ from: range.head, insert: before });
+        }
+        else {
+            iterateOverRangeLines(state.doc, range, (line) => {
+                if (skipEmptyLine && line.length === 0)
+                    return;
+                changes.push({ from: line.from, insert: before });
+            });
+        }
+        const changeSet = state.changes(changes);
+        return { changes: changeSet, range: range.map(changeSet, 1) };
+    });
+    dispatch(state.update(tr));
+    return true;
+};
+exports.wrapPerLine = wrapPerLine;
+function iterateOverRangeLines(doc, range, fn) {
+    const from = doc.lineAt(range.from).number;
+    const to = doc.lineAt(range.to).number;
+    for (let i = from; i <= to; i++) {
+        fn(doc.line(i));
+    }
+}
+exports.iterateOverRangeLines = iterateOverRangeLines;

package/build/cjs/markup/commands/index.d.ts

@@ -0,0 +1,9 @@
+export { redo, redoDepth, undo, undoDepth } from '@codemirror/commands';
+export * from './blocks';
+export * from './code';
+export * from './heading';
+export * from './inline';
+export * from './lists';
+export * from './marks';
+export * from './math';
+export * from './yfm';

package/build/cjs/markup/commands/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undoDepth = exports.undo = exports.redoDepth = exports.redo = void 0;
+const tslib_1 = require("tslib");
+var commands_1 = require("@codemirror/commands");
+Object.defineProperty(exports, "redo", { enumerable: true, get: function () { return commands_1.redo; } });
+Object.defineProperty(exports, "redoDepth", { enumerable: true, get: function () { return commands_1.redoDepth; } });
+Object.defineProperty(exports, "undo", { enumerable: true, get: function () { return commands_1.undo; } });
+Object.defineProperty(exports, "undoDepth", { enumerable: true, get: function () { return commands_1.undoDepth; } });
+tslib_1.__exportStar(require("./blocks"), exports);
+tslib_1.__exportStar(require("./code"), exports);
+tslib_1.__exportStar(require("./heading"), exports);
+tslib_1.__exportStar(require("./inline"), exports);
+tslib_1.__exportStar(require("./lists"), exports);
+tslib_1.__exportStar(require("./marks"), exports);
+tslib_1.__exportStar(require("./math"), exports);
+tslib_1.__exportStar(require("./yfm"), exports);

package/build/cjs/markup/commands/inline.d.ts

@@ -0,0 +1,17 @@
+import type { StateCommand } from '@codemirror/state';
+export declare const insertLink: StateCommand;
+export declare const insertAnchor: StateCommand;
+export declare type ImageItem = {
+    url?: string;
+    title?: string;
+    alt?: string;
+    width?: string;
+    height?: string;
+};
+export declare function insertImages(images: ImageItem[]): StateCommand;
+export declare type FileItem = {
+    src: string;
+    name: string;
+    type?: string;
+};
+export declare const insertFiles: (files: FileItem[]) => StateCommand;