@fewangsit/wangsvue 1.5.219-alpha.0 → 1.5.219-alpha.2

package/vendor/@tiptap/extension-link/dist/index.es.js

@@ -1,88 +1,141 @@
-import { M as b, a as C, m as v, e as T, f as w, h as E, j as H, k as B } from "../../core/dist/index.es.js";
-import { f as M, r as y, t as O, a as U } from "../../../linkifyjs/dist/linkify.es.es.js";
-import { P as m, a as A } from "../../../prosemirror-state/dist/index.es.js";
-function V(t) {
-  return t.length === 1 ? t[0].isLink : t.length === 3 && t[1].isLink ? ["()", "[]"].includes(t[0].value + t[2].value) : !1;
+import { M as Mark, a as markPasteRule, m as mergeAttributes, e as combineTransactionSteps, f as getChangedRanges, h as findChildrenInRange, j as getMarksBetween, k as getAttributes } from "../../core/dist/index.es.js";
+import { f as find, r as registerCustomProtocol, t as tokenize, a as reset } from "../../../linkifyjs/dist/linkify.es.es.js";
+import { P as Plugin, a as PluginKey } from "../../../prosemirror-state/dist/index.es.js";
+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;
 }
-function R(t) {
-  return new m({
-    key: new A("autolink"),
-    appendTransaction: (e, n, o) => {
-      const i = e.some((s) => s.docChanged) && !n.doc.eq(o.doc), l = e.some((s) => s.getMeta("preventAutolink"));
-      if (!i || l)
+function autolink(options) {
+  return new Plugin({
+    key: new PluginKey("autolink"),
+    appendTransaction: (transactions, oldState, newState) => {
+      const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
+      const preventAutolink = transactions.some((transaction) => transaction.getMeta("preventAutolink"));
+      if (!docChanges || preventAutolink) {
         return;
-      const { tr: a } = o, f = T(n.doc, [...e]);
-      if (w(f).forEach(({ newRange: s }) => {
-        const d = E(o.doc, s, (k) => k.isTextblock);
-        let u, c;
-        if (d.length > 1 ? (u = d[0], c = o.doc.textBetween(u.pos, u.pos + u.node.nodeSize, void 0, " ")) : d.length && o.doc.textBetween(s.from, s.to, " ", " ").endsWith(" ") && (u = d[0], c = o.doc.textBetween(u.pos, s.to, void 0, " ")), u && c) {
-          const k = c.split(" ").filter((r) => r !== "");
-          if (k.length <= 0)
-            return !1;
-          const g = k[k.length - 1], P = u.pos + c.lastIndexOf(g);
-          if (!g)
-            return !1;
-          const L = O(g).map((r) => r.toObject(t.defaultProtocol));
-          if (!V(L))
-            return !1;
-          L.filter((r) => r.isLink).map((r) => ({
-            ...r,
-            from: P + r.start + 1,
-            to: P + r.end + 1
-          })).filter((r) => o.schema.marks.code ? !o.doc.rangeHasMark(r.from, r.to, o.schema.marks.code) : !0).filter((r) => t.validate(r.value)).filter((r) => t.shouldAutoLink(r.value)).forEach((r) => {
-            H(r.from, r.to, o.doc).some((x) => x.mark.type === t.type) || a.addMark(r.from, r.to, t.type.create({
-              href: r.href
+      }
+      const { tr } = newState;
+      const transform = combineTransactionSteps(oldState.doc, [...transactions]);
+      const changes = getChangedRanges(transform);
+      changes.forEach(({ newRange }) => {
+        const nodesInChangedRanges = findChildrenInRange(newState.doc, newRange, (node) => node.isTextblock);
+        let textBlock;
+        let textBeforeWhitespace;
+        if (nodesInChangedRanges.length > 1) {
+          textBlock = nodesInChangedRanges[0];
+          textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, textBlock.pos + textBlock.node.nodeSize, void 0, " ");
+        } else if (nodesInChangedRanges.length && newState.doc.textBetween(newRange.from, newRange.to, " ", " ").endsWith(" ")) {
+          textBlock = nodesInChangedRanges[0];
+          textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, newRange.to, void 0, " ");
+        }
+        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).map((link) => ({
+            ...link,
+            from: lastWordAndBlockOffset + link.start + 1,
+            to: lastWordAndBlockOffset + link.end + 1
+          })).filter((link) => {
+            if (!newState.schema.marks.code) {
+              return true;
+            }
+            return !newState.doc.rangeHasMark(link.from, link.to, newState.schema.marks.code);
+          }).filter((link) => options.validate(link.value)).filter((link) => options.shouldAutoLink(link.value)).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
             }));
           });
         }
-      }), !!a.steps.length)
-        return a;
+      });
+      if (!tr.steps.length) {
+        return;
+      }
+      return tr;
     }
   });
 }
-function W(t) {
-  return new m({
-    key: new A("handleClickLink"),
+function clickHandler(options) {
+  return new Plugin({
+    key: new PluginKey("handleClickLink"),
     props: {
-      handleClick: (e, n, o) => {
-        var i, l;
-        if (o.button !== 0 || !e.editable)
-          return !1;
-        let a = o.target;
-        const f = [];
-        for (; a.nodeName !== "DIV"; )
-          f.push(a), a = a.parentNode;
-        if (!f.find((c) => c.nodeName === "A"))
-          return !1;
-        const h = B(e.state, t.type.name), s = o.target, d = (i = s == null ? void 0 : s.href) !== null && i !== void 0 ? i : h.href, u = (l = s == null ? void 0 : s.target) !== null && l !== void 0 ? l : h.target;
-        return s && d ? (window.open(d, u), !0) : !1;
+      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 z(t) {
-  return new m({
-    key: new A("handlePasteLink"),
+function pasteHandler(options) {
+  return new Plugin({
+    key: new PluginKey("handlePasteLink"),
     props: {
-      handlePaste: (e, n, o) => {
-        const { state: i } = e, { selection: l } = i, { empty: a } = l;
-        if (a)
-          return !1;
-        let f = "";
-        o.content.forEach((s) => {
-          f += s.textContent;
+      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 h = M(f, { defaultProtocol: t.defaultProtocol }).find((s) => s.isLink && s.value === f);
-        return !f || !h ? !1 : t.editor.commands.setMark(t.type, {
-          href: h.href
+        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
         });
       }
     }
   });
 }
-const I = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
-function p(t, e) {
-  const n = [
+const ATTR_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+function isAllowedUri(uri, protocols) {
+  const allowedProtocols = [
     "http",
     "https",
     "ftp",
@@ -94,40 +147,49 @@ function p(t, e) {
     "cid",
     "xmpp"
   ];
-  return e && e.forEach((o) => {
-    const i = typeof o == "string" ? o : o.scheme;
-    i && n.push(i);
-  }), !t || t.replace(I, "").match(new RegExp(
+  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
-    `^(?:(?:${n.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
+    `^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
     "i"
   ));
 }
-const D = b.create({
+const Link = Mark.create({
   name: "link",
   priority: 1e3,
-  keepOnSplit: !1,
-  exitable: !0,
+  keepOnSplit: false,
+  exitable: true,
   onCreate() {
-    this.options.validate && !this.options.shouldAutoLink && (this.options.shouldAutoLink = this.options.validate, console.warn("The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.")), this.options.protocols.forEach((t) => {
-      if (typeof t == "string") {
-        y(t);
+    if (this.options.validate && !this.options.shouldAutoLink) {
+      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;
       }
-      y(t.scheme, t.optionalSlashes);
+      registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);
     });
   },
   onDestroy() {
-    U();
+    reset();
   },
   inclusive() {
     return this.options.autolink;
   },
   addOptions() {
     return {
-      openOnClick: !0,
-      linkOnPaste: !0,
-      autolink: !0,
+      openOnClick: true,
+      linkOnPaste: true,
+      autolink: true,
       protocols: [],
       defaultProtocol: "http",
       HTMLAttributes: {
@@ -135,17 +197,17 @@ const D = b.create({
         rel: "noopener noreferrer nofollow",
         class: null
       },
-      isAllowedUri: (t, e) => !!p(t, e.protocols),
-      validate: (t) => !!t,
-      shouldAutoLink: (t) => !!t
+      isAllowedUri: (url, ctx) => !!isAllowedUri(url, ctx.protocols),
+      validate: (url) => !!url,
+      shouldAutoLink: (url) => !!url
     };
   },
   addAttributes() {
     return {
       href: {
         default: null,
-        parseHTML(t) {
-          return t.getAttribute("href");
+        parseHTML(element) {
+          return element.getAttribute("href");
         }
       },
       target: {
@@ -163,100 +225,127 @@ const D = b.create({
     return [
       {
         tag: "a[href]",
-        getAttrs: (t) => {
-          const e = t.getAttribute("href");
-          return !e || !this.options.isAllowedUri(e, {
-            defaultValidate: (n) => !!p(n, this.options.protocols),
+        getAttrs: (dom) => {
+          const href = dom.getAttribute("href");
+          if (!href || !this.options.isAllowedUri(href, {
+            defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
             protocols: this.options.protocols,
             defaultProtocol: this.options.defaultProtocol
-          }) ? !1 : null;
+          })) {
+            return false;
+          }
+          return null;
         }
       }
     ];
   },
-  renderHTML({ HTMLAttributes: t }) {
-    return this.options.isAllowedUri(t.href, {
-      defaultValidate: (e) => !!p(e, this.options.protocols),
+  renderHTML({ HTMLAttributes }) {
+    if (!this.options.isAllowedUri(HTMLAttributes.href, {
+      defaultValidate: (href) => !!isAllowedUri(href, this.options.protocols),
       protocols: this.options.protocols,
       defaultProtocol: this.options.defaultProtocol
-    }) ? ["a", v(this.options.HTMLAttributes, t), 0] : [
-      "a",
-      v(this.options.HTMLAttributes, { ...t, href: "" }),
-      0
-    ];
+    })) {
+      return [
+        "a",
+        mergeAttributes(this.options.HTMLAttributes, { ...HTMLAttributes, href: "" }),
+        0
+      ];
+    }
+    return ["a", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
   },
   addCommands() {
     return {
-      setLink: (t) => ({ chain: e }) => {
-        const { href: n } = t;
-        return this.options.isAllowedUri(n, {
-          defaultValidate: (o) => !!p(o, this.options.protocols),
+      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
-        }) ? e().setMark(this.name, t).setMeta("preventAutolink", !0).run() : !1;
+        })) {
+          return false;
+        }
+        return chain().setMark(this.name, attributes).setMeta("preventAutolink", true).run();
       },
-      toggleLink: (t) => ({ chain: e }) => {
-        const { href: n } = t;
-        return this.options.isAllowedUri(n, {
-          defaultValidate: (o) => !!p(o, this.options.protocols),
+      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
-        }) ? e().toggleMark(this.name, t, { extendEmptyMarkRange: !0 }).setMeta("preventAutolink", !0).run() : !1;
+        })) {
+          return false;
+        }
+        return chain().toggleMark(this.name, attributes, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
       },
-      unsetLink: () => ({ chain: t }) => t().unsetMark(this.name, { extendEmptyMarkRange: !0 }).setMeta("preventAutolink", !0).run()
+      unsetLink: () => ({ chain }) => {
+        return chain().unsetMark(this.name, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
+      }
     };
   },
   addPasteRules() {
     return [
-      C({
-        find: (t) => {
-          const e = [];
-          if (t) {
-            const { protocols: n, defaultProtocol: o } = this.options, i = M(t).filter((l) => l.isLink && this.options.isAllowedUri(l.value, {
-              defaultValidate: (a) => !!p(a, n),
-              protocols: n,
-              defaultProtocol: o
-            }));
-            i.length && i.forEach((l) => e.push({
-              text: l.value,
-              data: {
-                href: l.href
-              },
-              index: l.start
+      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 e;
+          return foundLinks;
         },
         type: this.type,
-        getAttributes: (t) => {
-          var e;
+        getAttributes: (match) => {
+          var _a;
           return {
-            href: (e = t.data) === null || e === void 0 ? void 0 : e.href
+            href: (_a = match.data) === null || _a === void 0 ? void 0 : _a.href
           };
         }
       })
     ];
   },
   addProseMirrorPlugins() {
-    const t = [], { protocols: e, defaultProtocol: n } = this.options;
-    return this.options.autolink && t.push(R({
-      type: this.type,
-      defaultProtocol: this.options.defaultProtocol,
-      validate: (o) => this.options.isAllowedUri(o, {
-        defaultValidate: (i) => !!p(i, e),
-        protocols: e,
-        defaultProtocol: n
-      }),
-      shouldAutoLink: this.options.shouldAutoLink
-    })), this.options.openOnClick === !0 && t.push(W({
-      type: this.type
-    })), this.options.linkOnPaste && t.push(z({
-      editor: this.editor,
-      defaultProtocol: this.options.defaultProtocol,
-      type: this.type
-    })), t;
+    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 {
-  D as L
+  Link as L
 };

package/vendor/@tiptap/extension-list-item/dist/index.es.js

@@ -1,5 +1,5 @@
-import { N as e, m as i } from "../../core/dist/index.es.js";
-const s = e.create({
+import { N as Node, m as mergeAttributes } from "../../core/dist/index.es.js";
+const ListItem = Node.create({
   name: "listItem",
   addOptions() {
     return {
@@ -9,7 +9,7 @@ const s = e.create({
     };
   },
   content: "paragraph block*",
-  defining: !0,
+  defining: true,
   parseHTML() {
     return [
       {
@@ -17,8 +17,8 @@ const s = e.create({
       }
     ];
   },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["li", i(this.options.HTMLAttributes, t), 0];
+  renderHTML({ HTMLAttributes }) {
+    return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
   },
   addKeyboardShortcuts() {
     return {
@@ -29,5 +29,5 @@ const s = e.create({
   }
 });
 export {
-  s as L
+  ListItem as L
 };