@vc-shell/framework 1.1.46 → 1.1.47

package/dist/vendor-tiptap-extension-code-jVv6CXpX.js

@@ -1,75 +0,0 @@
-import { M as Mark, a as markPasteRule, b as markInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * Regular expressions to match inline code blocks enclosed in backticks.
- *  It matches:
- *     - An opening backtick, followed by
- *     - Any text that doesn't include a backtick (captured for marking), followed by
- *     - A closing backtick.
- *  This ensures that any text between backticks is formatted as code,
- *  regardless of the surrounding characters (exception being another backtick).
- */
-const inputRegex = /(^|[^`])`([^`]+)`(?!`)/;
-/**
- * Matches inline code while pasting.
- */
-const pasteRegex = /(^|[^`])`([^`]+)`(?!`)/g;
-/**
- * This extension allows you to mark text as inline code.
- * @see https://tiptap.dev/api/marks/code
- */
-const Code = Mark.create({
-    name: 'code',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    excludes: '_',
-    code: true,
-    exitable: true,
-    parseHTML() {
-        return [
-            { tag: 'code' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['code', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setCode: () => ({ commands }) => {
-                return commands.setMark(this.name);
-            },
-            toggleCode: () => ({ commands }) => {
-                return commands.toggleMark(this.name);
-            },
-            unsetCode: () => ({ commands }) => {
-                return commands.unsetMark(this.name);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-e': () => this.editor.commands.toggleCode(),
-        };
-    },
-    addInputRules() {
-        return [
-            markInputRule({
-                find: inputRegex,
-                type: this.type,
-            }),
-        ];
-    },
-    addPasteRules() {
-        return [
-            markPasteRule({
-                find: pasteRegex,
-                type: this.type,
-            }),
-        ];
-    },
-});
-
-export { Code as C };

package/dist/vendor-tiptap-extension-document-DssuotYs.js

@@ -1,13 +0,0 @@
-import { N as Node } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * The default document node which represents the top level node of the editor.
- * @see https://tiptap.dev/api/nodes/document
- */
-const Document = Node.create({
-    name: 'doc',
-    topNode: true,
-    content: 'block+',
-});
-
-export { Document as D };

package/dist/vendor-tiptap-extension-dropcursor-BoO0Qv91.js

@@ -1,26 +0,0 @@
-import { E as Extension } from './vendor-tiptap-core-NfwGfaQk.js';
-import { d as dropCursor } from './vendor-prosemirror-dropcursor-CeyPcxrA.js';
-
-/**
- * This extension allows you to add a drop cursor to your editor.
- * A drop cursor is a line that appears when you drag and drop content
- * inbetween nodes.
- * @see https://tiptap.dev/api/extensions/dropcursor
- */
-const Dropcursor = Extension.create({
-    name: 'dropCursor',
-    addOptions() {
-        return {
-            color: 'currentColor',
-            width: 1,
-            class: undefined,
-        };
-    },
-    addProseMirrorPlugins() {
-        return [
-            dropCursor(this.options),
-        ];
-    },
-});
-
-export { Dropcursor as D };

package/dist/vendor-tiptap-extension-floating-menu-CrO8CN5w.js

@@ -1,165 +0,0 @@
-import { g as getText, d as getTextSerializersFromSchema, p as posToDOMRect, E as Extension } from './vendor-tiptap-core-NfwGfaQk.js';
-import { t as tippy } from './vendor-tippy-js-DWFe2TfK.js';
-import { P as Plugin, a as PluginKey } from './vendor-prosemirror-state-BvL9Pxph.js';
-
-class FloatingMenuView {
-    getTextContent(node) {
-        return getText(node, { textSerializers: getTextSerializersFromSchema(this.editor.schema) });
-    }
-    constructor({ editor, element, view, tippyOptions = {}, shouldShow, }) {
-        this.preventHide = false;
-        this.shouldShow = ({ view, state }) => {
-            const { selection } = state;
-            const { $anchor, empty } = selection;
-            const isRootDepth = $anchor.depth === 1;
-            const isEmptyTextBlock = $anchor.parent.isTextblock && !$anchor.parent.type.spec.code && !$anchor.parent.textContent && $anchor.parent.childCount === 0 && !this.getTextContent($anchor.parent);
-            if (!view.hasFocus()
-                || !empty
-                || !isRootDepth
-                || !isEmptyTextBlock
-                || !this.editor.isEditable) {
-                return false;
-            }
-            return true;
-        };
-        this.mousedownHandler = () => {
-            this.preventHide = true;
-        };
-        this.focusHandler = () => {
-            // we use `setTimeout` to make sure `selection` is already updated
-            setTimeout(() => this.update(this.editor.view));
-        };
-        this.blurHandler = ({ event }) => {
-            var _a;
-            if (this.preventHide) {
-                this.preventHide = false;
-                return;
-            }
-            if ((event === null || event === void 0 ? void 0 : event.relatedTarget) && ((_a = this.element.parentNode) === null || _a === void 0 ? void 0 : _a.contains(event.relatedTarget))) {
-                return;
-            }
-            if ((event === null || event === void 0 ? void 0 : event.relatedTarget) === this.editor.view.dom) {
-                return;
-            }
-            this.hide();
-        };
-        this.tippyBlurHandler = (event) => {
-            this.blurHandler({ event });
-        };
-        this.editor = editor;
-        this.element = element;
-        this.view = view;
-        if (shouldShow) {
-            this.shouldShow = shouldShow;
-        }
-        this.element.addEventListener('mousedown', this.mousedownHandler, { capture: true });
-        this.editor.on('focus', this.focusHandler);
-        this.editor.on('blur', this.blurHandler);
-        this.tippyOptions = tippyOptions;
-        // Detaches menu content from its current parent
-        this.element.remove();
-        this.element.style.visibility = 'visible';
-    }
-    createTooltip() {
-        const { element: editorElement } = this.editor.options;
-        const editorIsAttached = !!editorElement.parentElement;
-        if (this.tippy || !editorIsAttached) {
-            return;
-        }
-        this.tippy = tippy(editorElement, {
-            duration: 0,
-            getReferenceClientRect: null,
-            content: this.element,
-            interactive: true,
-            trigger: 'manual',
-            placement: 'right',
-            hideOnClick: 'toggle',
-            ...this.tippyOptions,
-        });
-        // maybe we have to hide tippy on its own blur event as well
-        if (this.tippy.popper.firstChild) {
-            this.tippy.popper.firstChild.addEventListener('blur', this.tippyBlurHandler);
-        }
-    }
-    update(view, oldState) {
-        var _a, _b, _c;
-        const { state } = view;
-        const { doc, selection } = state;
-        const { from, to } = selection;
-        const isSame = oldState && oldState.doc.eq(doc) && oldState.selection.eq(selection);
-        if (isSame) {
-            return;
-        }
-        this.createTooltip();
-        const shouldShow = (_a = this.shouldShow) === null || _a === void 0 ? void 0 : _a.call(this, {
-            editor: this.editor,
-            view,
-            state,
-            oldState,
-        });
-        if (!shouldShow) {
-            this.hide();
-            return;
-        }
-        (_b = this.tippy) === null || _b === void 0 ? void 0 : _b.setProps({
-            getReferenceClientRect: ((_c = this.tippyOptions) === null || _c === void 0 ? void 0 : _c.getReferenceClientRect) || (() => posToDOMRect(view, from, to)),
-        });
-        this.show();
-    }
-    show() {
-        var _a;
-        (_a = this.tippy) === null || _a === void 0 ? void 0 : _a.show();
-    }
-    hide() {
-        var _a;
-        (_a = this.tippy) === null || _a === void 0 ? void 0 : _a.hide();
-    }
-    destroy() {
-        var _a, _b;
-        if ((_a = this.tippy) === null || _a === void 0 ? void 0 : _a.popper.firstChild) {
-            this.tippy.popper.firstChild.removeEventListener('blur', this.tippyBlurHandler);
-        }
-        (_b = this.tippy) === null || _b === void 0 ? void 0 : _b.destroy();
-        this.element.removeEventListener('mousedown', this.mousedownHandler, { capture: true });
-        this.editor.off('focus', this.focusHandler);
-        this.editor.off('blur', this.blurHandler);
-    }
-}
-const FloatingMenuPlugin = (options) => {
-    return new Plugin({
-        key: typeof options.pluginKey === 'string' ? new PluginKey(options.pluginKey) : options.pluginKey,
-        view: view => new FloatingMenuView({ view, ...options }),
-    });
-};
-
-/**
- * This extension allows you to create a floating menu.
- * @see https://tiptap.dev/api/extensions/floating-menu
- */
-Extension.create({
-    name: 'floatingMenu',
-    addOptions() {
-        return {
-            element: null,
-            tippyOptions: {},
-            pluginKey: 'floatingMenu',
-            shouldShow: null,
-        };
-    },
-    addProseMirrorPlugins() {
-        if (!this.options.element) {
-            return [];
-        }
-        return [
-            FloatingMenuPlugin({
-                pluginKey: this.options.pluginKey,
-                editor: this.editor,
-                element: this.options.element,
-                tippyOptions: this.options.tippyOptions,
-                shouldShow: this.options.shouldShow,
-            }),
-        ];
-    },
-});
-
-export { FloatingMenuPlugin as F };

package/dist/vendor-tiptap-extension-gapcursor-KpsWEoMD.js

@@ -1,30 +0,0 @@
-import { E as Extension, e as callOrReturn, f as getExtensionField } from './vendor-tiptap-core-NfwGfaQk.js';
-import { g as gapCursor } from './vendor-prosemirror-gapcursor-U8UoUJII.js';
-
-/**
- * This extension allows you to add a gap cursor to your editor.
- * A gap cursor is a cursor that appears when you click on a place
- * where no content is present, for example inbetween nodes.
- * @see https://tiptap.dev/api/extensions/gapcursor
- */
-const Gapcursor = Extension.create({
-    name: 'gapCursor',
-    addProseMirrorPlugins() {
-        return [
-            gapCursor(),
-        ];
-    },
-    extendNodeSchema(extension) {
-        var _a;
-        const context = {
-            name: extension.name,
-            options: extension.options,
-            storage: extension.storage,
-        };
-        return {
-            allowGapCursor: (_a = callOrReturn(getExtensionField(extension, 'allowGapCursor', context))) !== null && _a !== void 0 ? _a : null,
-        };
-    },
-});
-
-export { Gapcursor as G };

package/dist/vendor-tiptap-extension-hard-break-ldOzhSvf.js

@@ -1,68 +0,0 @@
-import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * This extension allows you to insert hard breaks.
- * @see https://www.tiptap.dev/api/nodes/hard-break
- */
-const HardBreak = Node.create({
-    name: 'hardBreak',
-    addOptions() {
-        return {
-            keepMarks: true,
-            HTMLAttributes: {},
-        };
-    },
-    inline: true,
-    group: 'inline',
-    selectable: false,
-    linebreakReplacement: true,
-    parseHTML() {
-        return [
-            { tag: 'br' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['br', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
-    },
-    renderText() {
-        return '\n';
-    },
-    addCommands() {
-        return {
-            setHardBreak: () => ({ commands, chain, state, editor, }) => {
-                return commands.first([
-                    () => commands.exitCode(),
-                    () => commands.command(() => {
-                        const { selection, storedMarks } = state;
-                        if (selection.$from.parent.type.spec.isolating) {
-                            return false;
-                        }
-                        const { keepMarks } = this.options;
-                        const { splittableMarks } = editor.extensionManager;
-                        const marks = storedMarks
-                            || (selection.$to.parentOffset && selection.$from.marks());
-                        return chain()
-                            .insertContent({ type: this.name })
-                            .command(({ tr, dispatch }) => {
-                            if (dispatch && marks && keepMarks) {
-                                const filteredMarks = marks
-                                    .filter(mark => splittableMarks.includes(mark.type.name));
-                                tr.ensureMarks(filteredMarks);
-                            }
-                            return true;
-                        })
-                            .run();
-                    }),
-                ]);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-Enter': () => this.editor.commands.setHardBreak(),
-            'Shift-Enter': () => this.editor.commands.setHardBreak(),
-        };
-    },
-});
-
-export { HardBreak as H };

package/dist/vendor-tiptap-extension-heading-CKz2llX0.js

@@ -1,77 +0,0 @@
-import { N as Node, t as textblockTypeInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * This extension allows you to create headings.
- * @see https://www.tiptap.dev/api/nodes/heading
- */
-const Heading = Node.create({
-    name: 'heading',
-    addOptions() {
-        return {
-            levels: [1, 2, 3, 4, 5, 6],
-            HTMLAttributes: {},
-        };
-    },
-    content: 'inline*',
-    group: 'block',
-    defining: true,
-    addAttributes() {
-        return {
-            level: {
-                default: 1,
-                rendered: false,
-            },
-        };
-    },
-    parseHTML() {
-        return this.options.levels
-            .map((level) => ({
-            tag: `h${level}`,
-            attrs: { level },
-        }));
-    },
-    renderHTML({ node, HTMLAttributes }) {
-        const hasLevel = this.options.levels.includes(node.attrs.level);
-        const level = hasLevel
-            ? node.attrs.level
-            : this.options.levels[0];
-        return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setHeading: attributes => ({ commands }) => {
-                if (!this.options.levels.includes(attributes.level)) {
-                    return false;
-                }
-                return commands.setNode(this.name, attributes);
-            },
-            toggleHeading: attributes => ({ commands }) => {
-                if (!this.options.levels.includes(attributes.level)) {
-                    return false;
-                }
-                return commands.toggleNode(this.name, 'paragraph', attributes);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return this.options.levels.reduce((items, level) => ({
-            ...items,
-            ...{
-                [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level }),
-            },
-        }), {});
-    },
-    addInputRules() {
-        return this.options.levels.map(level => {
-            return textblockTypeInputRule({
-                find: new RegExp(`^(#{${Math.min(...this.options.levels)},${level}})\\s$`),
-                type: this.type,
-                getAttributes: {
-                    level,
-                },
-            });
-        });
-    },
-});
-
-export { Heading as H };

package/dist/vendor-tiptap-extension-history-DeKZ2VQ9.js

@@ -1,48 +0,0 @@
-import { E as Extension } from './vendor-tiptap-core-NfwGfaQk.js';
-import { h as history, r as redo, u as undo } from './vendor-prosemirror-history-BDaJkvNx.js';
-
-/**
- * This extension allows you to undo and redo recent changes.
- * @see https://www.tiptap.dev/api/extensions/history
- *
- * **Important**: If the `@tiptap/extension-collaboration` package is used, make sure to remove
- * the `history` extension, as it is not compatible with the `collaboration` extension.
- *
- * `@tiptap/extension-collaboration` uses its own history implementation.
- */
-const History = Extension.create({
-    name: 'history',
-    addOptions() {
-        return {
-            depth: 100,
-            newGroupDelay: 500,
-        };
-    },
-    addCommands() {
-        return {
-            undo: () => ({ state, dispatch }) => {
-                return undo(state, dispatch);
-            },
-            redo: () => ({ state, dispatch }) => {
-                return redo(state, dispatch);
-            },
-        };
-    },
-    addProseMirrorPlugins() {
-        return [
-            history(this.options),
-        ];
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-z': () => this.editor.commands.undo(),
-            'Shift-Mod-z': () => this.editor.commands.redo(),
-            'Mod-y': () => this.editor.commands.redo(),
-            // Russian keyboard layouts
-            'Mod-я': () => this.editor.commands.undo(),
-            'Shift-Mod-я': () => this.editor.commands.redo(),
-        };
-    },
-});
-
-export { History as H };

package/dist/vendor-tiptap-extension-horizontal-rule-CAjWRyDS.js

@@ -1,92 +0,0 @@
-import { N as Node, n as nodeInputRule, h as canInsertNode, c as isNodeSelection, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-import { T as TextSelection, N as NodeSelection } from './vendor-prosemirror-state-BvL9Pxph.js';
-
-/**
- * This extension allows you to insert horizontal rules.
- * @see https://www.tiptap.dev/api/nodes/horizontal-rule
- */
-const HorizontalRule = Node.create({
-    name: 'horizontalRule',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    group: 'block',
-    parseHTML() {
-        return [{ tag: 'hr' }];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['hr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
-    },
-    addCommands() {
-        return {
-            setHorizontalRule: () => ({ chain, state }) => {
-                // Check if we can insert the node at the current selection
-                if (!canInsertNode(state, state.schema.nodes[this.name])) {
-                    return false;
-                }
-                const { selection } = state;
-                const { $from: $originFrom, $to: $originTo } = selection;
-                const currentChain = chain();
-                if ($originFrom.parentOffset === 0) {
-                    currentChain.insertContentAt({
-                        from: Math.max($originFrom.pos - 1, 0),
-                        to: $originTo.pos,
-                    }, {
-                        type: this.name,
-                    });
-                }
-                else if (isNodeSelection(selection)) {
-                    currentChain.insertContentAt($originTo.pos, {
-                        type: this.name,
-                    });
-                }
-                else {
-                    currentChain.insertContent({ type: this.name });
-                }
-                return (currentChain
-                    // set cursor after horizontal rule
-                    .command(({ tr, dispatch }) => {
-                    var _a;
-                    if (dispatch) {
-                        const { $to } = tr.selection;
-                        const posAfter = $to.end();
-                        if ($to.nodeAfter) {
-                            if ($to.nodeAfter.isTextblock) {
-                                tr.setSelection(TextSelection.create(tr.doc, $to.pos + 1));
-                            }
-                            else if ($to.nodeAfter.isBlock) {
-                                tr.setSelection(NodeSelection.create(tr.doc, $to.pos));
-                            }
-                            else {
-                                tr.setSelection(TextSelection.create(tr.doc, $to.pos));
-                            }
-                        }
-                        else {
-                            // add node after horizontal rule if it’s the end of the document
-                            const node = (_a = $to.parent.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.create();
-                            if (node) {
-                                tr.insert(posAfter, node);
-                                tr.setSelection(TextSelection.create(tr.doc, posAfter + 1));
-                            }
-                        }
-                        tr.scrollIntoView();
-                    }
-                    return true;
-                })
-                    .run());
-            },
-        };
-    },
-    addInputRules() {
-        return [
-            nodeInputRule({
-                find: /^(?:---|—-|___\s|\*\*\*\s)$/,
-                type: this.type,
-            }),
-        ];
-    },
-});
-
-export { HorizontalRule as H };

package/dist/vendor-tiptap-extension-image-ZagcEYuk.js

@@ -1,76 +0,0 @@
-import { N as Node, n as nodeInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * Matches an image to a ![image](src "title") on input.
- */
-const inputRegex = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/;
-/**
- * This extension allows you to insert images.
- * @see https://www.tiptap.dev/api/nodes/image
- */
-const Image = Node.create({
-    name: 'image',
-    addOptions() {
-        return {
-            inline: false,
-            allowBase64: false,
-            HTMLAttributes: {},
-        };
-    },
-    inline() {
-        return this.options.inline;
-    },
-    group() {
-        return this.options.inline ? 'inline' : 'block';
-    },
-    draggable: true,
-    addAttributes() {
-        return {
-            src: {
-                default: null,
-            },
-            alt: {
-                default: null,
-            },
-            title: {
-                default: null,
-            },
-        };
-    },
-    parseHTML() {
-        return [
-            {
-                tag: this.options.allowBase64
-                    ? 'img[src]'
-                    : 'img[src]:not([src^="data:"])',
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['img', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
-    },
-    addCommands() {
-        return {
-            setImage: options => ({ commands }) => {
-                return commands.insertContent({
-                    type: this.name,
-                    attrs: options,
-                });
-            },
-        };
-    },
-    addInputRules() {
-        return [
-            nodeInputRule({
-                find: inputRegex,
-                type: this.type,
-                getAttributes: match => {
-                    const [, , alt, src, title] = match;
-                    return { src, alt, title };
-                },
-            }),
-        ];
-    },
-});
-
-export { Image as I };