@vc-shell/framework 1.1.44 → 1.1.45

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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,414 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,39 @@
+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 };