@vc-shell/framework 1.1.46 → 1.1.47

package/dist/vendor-tiptap-extension-italic-CM4xdznY.js

@@ -1,96 +0,0 @@
-import { M as Mark, a as markPasteRule, b as markInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * Matches an italic to a *italic* on input.
- */
-const starInputRegex = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/;
-/**
- * Matches an italic to a *italic* on paste.
- */
-const starPasteRegex = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g;
-/**
- * Matches an italic to a _italic_ on input.
- */
-const underscoreInputRegex = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/;
-/**
- * Matches an italic to a _italic_ on paste.
- */
-const underscorePasteRegex = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g;
-/**
- * This extension allows you to create italic text.
- * @see https://www.tiptap.dev/api/marks/italic
- */
-const Italic = Mark.create({
-    name: 'italic',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    parseHTML() {
-        return [
-            {
-                tag: 'em',
-            },
-            {
-                tag: 'i',
-                getAttrs: node => node.style.fontStyle !== 'normal' && null,
-            },
-            {
-                style: 'font-style=normal',
-                clearMark: mark => mark.type.name === this.name,
-            },
-            {
-                style: 'font-style=italic',
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['em', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setItalic: () => ({ commands }) => {
-                return commands.setMark(this.name);
-            },
-            toggleItalic: () => ({ commands }) => {
-                return commands.toggleMark(this.name);
-            },
-            unsetItalic: () => ({ commands }) => {
-                return commands.unsetMark(this.name);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-i': () => this.editor.commands.toggleItalic(),
-            'Mod-I': () => this.editor.commands.toggleItalic(),
-        };
-    },
-    addInputRules() {
-        return [
-            markInputRule({
-                find: starInputRegex,
-                type: this.type,
-            }),
-            markInputRule({
-                find: underscoreInputRegex,
-                type: this.type,
-            }),
-        ];
-    },
-    addPasteRules() {
-        return [
-            markPasteRule({
-                find: starPasteRegex,
-                type: this.type,
-            }),
-            markPasteRule({
-                find: underscorePasteRegex,
-                type: this.type,
-            }),
-        ];
-    },
-});
-
-export { Italic as I };

package/dist/vendor-tiptap-extension-link-Z-AMC4Ri.js

@@ -1,414 +0,0 @@
-import { M as Mark, a as markPasteRule, m as mergeAttributes, j as combineTransactionSteps, k as getChangedRanges, l as findChildrenInRange, o as getMarksBetween, q as getAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-import { r as registerCustomProtocol, t as tokenize, f as find, a as reset } from './vendor-linkifyjs-BfyGgbCh.js';
-import { P as Plugin, a as PluginKey } from './vendor-prosemirror-state-BvL9Pxph.js';
-
-/**
- * Check if the provided tokens form a valid link structure, which can either be a single link token
- * or a link token surrounded by parentheses or square brackets.
- *
- * This ensures that only complete and valid text is hyperlinked, preventing cases where a valid
- * top-level domain (TLD) is immediately followed by an invalid character, like a number. For
- * example, with the `find` method from Linkify, entering `example.com1` would result in
- * `example.com` being linked and the trailing `1` left as plain text. By using the `tokenize`
- * method, we can perform more comprehensive validation on the input text.
- */
-function isValidLinkStructure(tokens) {
-    if (tokens.length === 1) {
-        return tokens[0].isLink;
-    }
-    if (tokens.length === 3 && tokens[1].isLink) {
-        return ['()', '[]'].includes(tokens[0].value + tokens[2].value);
-    }
-    return false;
-}
-/**
- * This plugin allows you to automatically add links to your editor.
- * @param options The plugin options
- * @returns The plugin instance
- */
-function autolink(options) {
-    return new Plugin({
-        key: new PluginKey('autolink'),
-        appendTransaction: (transactions, oldState, newState) => {
-            /**
-             * Does the transaction change the document?
-             */
-            const docChanges = transactions.some(transaction => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-            /**
-             * Prevent autolink if the transaction is not a document change or if the transaction has the meta `preventAutolink`.
-             */
-            const preventAutolink = transactions.some(transaction => transaction.getMeta('preventAutolink'));
-            /**
-             * Prevent autolink if the transaction is not a document change
-             * or if the transaction has the meta `preventAutolink`.
-             */
-            if (!docChanges || preventAutolink) {
-                return;
-            }
-            const { tr } = newState;
-            const transform = combineTransactionSteps(oldState.doc, [...transactions]);
-            const changes = getChangedRanges(transform);
-            changes.forEach(({ newRange }) => {
-                // Now let’s see if we can add new links.
-                const nodesInChangedRanges = findChildrenInRange(newState.doc, newRange, node => node.isTextblock);
-                let textBlock;
-                let textBeforeWhitespace;
-                if (nodesInChangedRanges.length > 1) {
-                    // Grab the first node within the changed ranges (ex. the first of two paragraphs when hitting enter).
-                    textBlock = nodesInChangedRanges[0];
-                    textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, textBlock.pos + textBlock.node.nodeSize, undefined, ' ');
-                }
-                else if (nodesInChangedRanges.length
-                    // We want to make sure to include the block seperator argument to treat hard breaks like spaces.
-                    && newState.doc.textBetween(newRange.from, newRange.to, ' ', ' ').endsWith(' ')) {
-                    textBlock = nodesInChangedRanges[0];
-                    textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, newRange.to, undefined, ' ');
-                }
-                if (textBlock && textBeforeWhitespace) {
-                    const wordsBeforeWhitespace = textBeforeWhitespace.split(' ').filter(s => s !== '');
-                    if (wordsBeforeWhitespace.length <= 0) {
-                        return false;
-                    }
-                    const lastWordBeforeSpace = wordsBeforeWhitespace[wordsBeforeWhitespace.length - 1];
-                    const lastWordAndBlockOffset = textBlock.pos + textBeforeWhitespace.lastIndexOf(lastWordBeforeSpace);
-                    if (!lastWordBeforeSpace) {
-                        return false;
-                    }
-                    const linksBeforeSpace = tokenize(lastWordBeforeSpace).map(t => t.toObject(options.defaultProtocol));
-                    if (!isValidLinkStructure(linksBeforeSpace)) {
-                        return false;
-                    }
-                    linksBeforeSpace
-                        .filter(link => link.isLink)
-                        // Calculate link position.
-                        .map(link => ({
-                        ...link,
-                        from: lastWordAndBlockOffset + link.start + 1,
-                        to: lastWordAndBlockOffset + link.end + 1,
-                    }))
-                        // ignore link inside code mark
-                        .filter(link => {
-                        if (!newState.schema.marks.code) {
-                            return true;
-                        }
-                        return !newState.doc.rangeHasMark(link.from, link.to, newState.schema.marks.code);
-                    })
-                        // validate link
-                        .filter(link => options.validate(link.value))
-                        // check whether should autolink
-                        .filter(link => options.shouldAutoLink(link.value))
-                        // Add link mark.
-                        .forEach(link => {
-                        if (getMarksBetween(link.from, link.to, newState.doc).some(item => item.mark.type === options.type)) {
-                            return;
-                        }
-                        tr.addMark(link.from, link.to, options.type.create({
-                            href: link.href,
-                        }));
-                    });
-                }
-            });
-            if (!tr.steps.length) {
-                return;
-            }
-            return tr;
-        },
-    });
-}
-
-function clickHandler(options) {
-    return new Plugin({
-        key: new PluginKey('handleClickLink'),
-        props: {
-            handleClick: (view, pos, event) => {
-                var _a, _b;
-                if (event.button !== 0) {
-                    return false;
-                }
-                if (!view.editable) {
-                    return false;
-                }
-                let a = event.target;
-                const els = [];
-                while (a.nodeName !== 'DIV') {
-                    els.push(a);
-                    a = a.parentNode;
-                }
-                if (!els.find(value => value.nodeName === 'A')) {
-                    return false;
-                }
-                const attrs = getAttributes(view.state, options.type.name);
-                const link = event.target;
-                const href = (_a = link === null || link === void 0 ? void 0 : link.href) !== null && _a !== void 0 ? _a : attrs.href;
-                const target = (_b = link === null || link === void 0 ? void 0 : link.target) !== null && _b !== void 0 ? _b : attrs.target;
-                if (link && href) {
-                    window.open(href, target);
-                    return true;
-                }
-                return false;
-            },
-        },
-    });
-}
-
-function pasteHandler(options) {
-    return new Plugin({
-        key: new PluginKey('handlePasteLink'),
-        props: {
-            handlePaste: (view, event, slice) => {
-                const { state } = view;
-                const { selection } = state;
-                const { empty } = selection;
-                if (empty) {
-                    return false;
-                }
-                let textContent = '';
-                slice.content.forEach(node => {
-                    textContent += node.textContent;
-                });
-                const link = find(textContent, { defaultProtocol: options.defaultProtocol }).find(item => item.isLink && item.value === textContent);
-                if (!textContent || !link) {
-                    return false;
-                }
-                return options.editor.commands.setMark(options.type, {
-                    href: link.href,
-                });
-            },
-        },
-    });
-}
-// From DOMPurify
-// https://github.com/cure53/DOMPurify/blob/main/src/regexp.js
-// eslint-disable-next-line no-control-regex
-const ATTR_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
-function isAllowedUri(uri, protocols) {
-    const allowedProtocols = [
-        'http',
-        'https',
-        'ftp',
-        'ftps',
-        'mailto',
-        'tel',
-        'callto',
-        'sms',
-        'cid',
-        'xmpp',
-    ];
-    if (protocols) {
-        protocols.forEach(protocol => {
-            const nextProtocol = typeof protocol === 'string' ? protocol : protocol.scheme;
-            if (nextProtocol) {
-                allowedProtocols.push(nextProtocol);
-            }
-        });
-    }
-    return (!uri
-        || uri
-            .replace(ATTR_WHITESPACE, '')
-            .match(new RegExp(
-        // eslint-disable-next-line no-useless-escape
-        `^(?:(?:${allowedProtocols.join('|')}):|[^a-z]|[a-z0-9+.\-]+(?:[^a-z+.\-:]|$))`, 'i')));
-}
-/**
- * This extension allows you to create links.
- * @see https://www.tiptap.dev/api/marks/link
- */
-const Link = Mark.create({
-    name: 'link',
-    priority: 1000,
-    keepOnSplit: false,
-    exitable: true,
-    onCreate() {
-        if (this.options.validate && !this.options.shouldAutoLink) {
-            // Copy the validate function to the shouldAutoLink option
-            this.options.shouldAutoLink = this.options.validate;
-            console.warn('The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.');
-        }
-        this.options.protocols.forEach(protocol => {
-            if (typeof protocol === 'string') {
-                registerCustomProtocol(protocol);
-                return;
-            }
-            registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);
-        });
-    },
-    onDestroy() {
-        reset();
-    },
-    inclusive() {
-        return this.options.autolink;
-    },
-    addOptions() {
-        return {
-            openOnClick: true,
-            linkOnPaste: true,
-            autolink: true,
-            protocols: [],
-            defaultProtocol: 'http',
-            HTMLAttributes: {
-                target: '_blank',
-                rel: 'noopener noreferrer nofollow',
-                class: null,
-            },
-            isAllowedUri: (url, ctx) => !!isAllowedUri(url, ctx.protocols),
-            validate: url => !!url,
-            shouldAutoLink: url => !!url,
-        };
-    },
-    addAttributes() {
-        return {
-            href: {
-                default: null,
-                parseHTML(element) {
-                    return element.getAttribute('href');
-                },
-            },
-            target: {
-                default: this.options.HTMLAttributes.target,
-            },
-            rel: {
-                default: this.options.HTMLAttributes.rel,
-            },
-            class: {
-                default: this.options.HTMLAttributes.class,
-            },
-        };
-    },
-    parseHTML() {
-        return [
-            {
-                tag: 'a[href]',
-                getAttrs: dom => {
-                    const href = dom.getAttribute('href');
-                    // prevent XSS attacks
-                    if (!href
-                        || !this.options.isAllowedUri(href, {
-                            defaultValidate: url => !!isAllowedUri(url, this.options.protocols),
-                            protocols: this.options.protocols,
-                            defaultProtocol: this.options.defaultProtocol,
-                        })) {
-                        return false;
-                    }
-                    return null;
-                },
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        // prevent XSS attacks
-        if (!this.options.isAllowedUri(HTMLAttributes.href, {
-            defaultValidate: href => !!isAllowedUri(href, this.options.protocols),
-            protocols: this.options.protocols,
-            defaultProtocol: this.options.defaultProtocol,
-        })) {
-            // strip out the href
-            return [
-                'a',
-                mergeAttributes(this.options.HTMLAttributes, { ...HTMLAttributes, href: '' }),
-                0,
-            ];
-        }
-        return ['a', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setLink: attributes => ({ chain }) => {
-                const { href } = attributes;
-                if (!this.options.isAllowedUri(href, {
-                    defaultValidate: url => !!isAllowedUri(url, this.options.protocols),
-                    protocols: this.options.protocols,
-                    defaultProtocol: this.options.defaultProtocol,
-                })) {
-                    return false;
-                }
-                return chain().setMark(this.name, attributes).setMeta('preventAutolink', true).run();
-            },
-            toggleLink: attributes => ({ chain }) => {
-                const { href } = attributes;
-                if (!this.options.isAllowedUri(href, {
-                    defaultValidate: url => !!isAllowedUri(url, this.options.protocols),
-                    protocols: this.options.protocols,
-                    defaultProtocol: this.options.defaultProtocol,
-                })) {
-                    return false;
-                }
-                return chain()
-                    .toggleMark(this.name, attributes, { extendEmptyMarkRange: true })
-                    .setMeta('preventAutolink', true)
-                    .run();
-            },
-            unsetLink: () => ({ chain }) => {
-                return chain()
-                    .unsetMark(this.name, { extendEmptyMarkRange: true })
-                    .setMeta('preventAutolink', true)
-                    .run();
-            },
-        };
-    },
-    addPasteRules() {
-        return [
-            markPasteRule({
-                find: text => {
-                    const foundLinks = [];
-                    if (text) {
-                        const { protocols, defaultProtocol } = this.options;
-                        const links = find(text).filter(item => item.isLink
-                            && this.options.isAllowedUri(item.value, {
-                                defaultValidate: href => !!isAllowedUri(href, protocols),
-                                protocols,
-                                defaultProtocol,
-                            }));
-                        if (links.length) {
-                            links.forEach(link => foundLinks.push({
-                                text: link.value,
-                                data: {
-                                    href: link.href,
-                                },
-                                index: link.start,
-                            }));
-                        }
-                    }
-                    return foundLinks;
-                },
-                type: this.type,
-                getAttributes: match => {
-                    var _a;
-                    return {
-                        href: (_a = match.data) === null || _a === void 0 ? void 0 : _a.href,
-                    };
-                },
-            }),
-        ];
-    },
-    addProseMirrorPlugins() {
-        const plugins = [];
-        const { protocols, defaultProtocol } = this.options;
-        if (this.options.autolink) {
-            plugins.push(autolink({
-                type: this.type,
-                defaultProtocol: this.options.defaultProtocol,
-                validate: url => this.options.isAllowedUri(url, {
-                    defaultValidate: href => !!isAllowedUri(href, protocols),
-                    protocols,
-                    defaultProtocol,
-                }),
-                shouldAutoLink: this.options.shouldAutoLink,
-            }));
-        }
-        if (this.options.openOnClick === true) {
-            plugins.push(clickHandler({
-                type: this.type,
-            }));
-        }
-        if (this.options.linkOnPaste) {
-            plugins.push(pasteHandler({
-                editor: this.editor,
-                defaultProtocol: this.options.defaultProtocol,
-                type: this.type,
-            }));
-        }
-        return plugins;
-    },
-});
-
-export { Link as L };

package/dist/vendor-tiptap-extension-list-item-BJi5QpXc.js

@@ -1,37 +0,0 @@
-import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * This extension allows you to create list items.
- * @see https://www.tiptap.dev/api/nodes/list-item
- */
-const ListItem = Node.create({
-    name: 'listItem',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-            bulletListTypeName: 'bulletList',
-            orderedListTypeName: 'orderedList',
-        };
-    },
-    content: 'paragraph block*',
-    defining: true,
-    parseHTML() {
-        return [
-            {
-                tag: 'li',
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['li', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addKeyboardShortcuts() {
-        return {
-            Enter: () => this.editor.commands.splitListItem(this.name),
-            Tab: () => this.editor.commands.sinkListItem(this.name),
-            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
-        };
-    },
-});
-
-export { ListItem as L };

package/dist/vendor-tiptap-extension-ordered-list-C_TMrfBE.js

@@ -1,97 +0,0 @@
-import { N as Node, w as wrappingInputRule, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-const ListItemName = 'listItem';
-const TextStyleName = 'textStyle';
-/**
- * Matches an ordered list to a 1. on input (or any number followed by a dot).
- */
-const inputRegex = /^(\d+)\.\s$/;
-/**
- * This extension allows you to create ordered lists.
- * This requires the ListItem extension
- * @see https://www.tiptap.dev/api/nodes/ordered-list
- * @see https://www.tiptap.dev/api/nodes/list-item
- */
-const OrderedList = Node.create({
-    name: 'orderedList',
-    addOptions() {
-        return {
-            itemTypeName: 'listItem',
-            HTMLAttributes: {},
-            keepMarks: false,
-            keepAttributes: false,
-        };
-    },
-    group: 'block list',
-    content() {
-        return `${this.options.itemTypeName}+`;
-    },
-    addAttributes() {
-        return {
-            start: {
-                default: 1,
-                parseHTML: element => {
-                    return element.hasAttribute('start')
-                        ? parseInt(element.getAttribute('start') || '', 10)
-                        : 1;
-                },
-            },
-            type: {
-                default: null,
-                parseHTML: element => element.getAttribute('type'),
-            },
-        };
-    },
-    parseHTML() {
-        return [
-            {
-                tag: 'ol',
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        const { start, ...attributesWithoutStart } = HTMLAttributes;
-        return start === 1
-            ? ['ol', mergeAttributes(this.options.HTMLAttributes, attributesWithoutStart), 0]
-            : ['ol', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            toggleOrderedList: () => ({ commands, chain }) => {
-                if (this.options.keepAttributes) {
-                    return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
-                }
-                return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-Shift-7': () => this.editor.commands.toggleOrderedList(),
-        };
-    },
-    addInputRules() {
-        let inputRule = wrappingInputRule({
-            find: inputRegex,
-            type: this.type,
-            getAttributes: match => ({ start: +match[1] }),
-            joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
-        });
-        if (this.options.keepMarks || this.options.keepAttributes) {
-            inputRule = wrappingInputRule({
-                find: inputRegex,
-                type: this.type,
-                keepMarks: this.options.keepMarks,
-                keepAttributes: this.options.keepAttributes,
-                getAttributes: match => ({ start: +match[1], ...this.editor.getAttributes(TextStyleName) }),
-                joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
-                editor: this.editor,
-            });
-        }
-        return [
-            inputRule,
-        ];
-    },
-});
-
-export { OrderedList as O };

package/dist/vendor-tiptap-extension-paragraph-CQw0E0Au.js

@@ -1,39 +0,0 @@
-import { N as Node, m as mergeAttributes } from './vendor-tiptap-core-NfwGfaQk.js';
-
-/**
- * This extension allows you to create paragraphs.
- * @see https://www.tiptap.dev/api/nodes/paragraph
- */
-const Paragraph = Node.create({
-    name: 'paragraph',
-    priority: 1000,
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    group: 'block',
-    content: 'inline*',
-    parseHTML() {
-        return [
-            { tag: 'p' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['p', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addCommands() {
-        return {
-            setParagraph: () => ({ commands }) => {
-                return commands.setNode(this.name);
-            },
-        };
-    },
-    addKeyboardShortcuts() {
-        return {
-            'Mod-Alt-0': () => this.editor.commands.setParagraph(),
-        };
-    },
-});
-
-export { Paragraph as P };