@lunejs/admin-ui 0.1.4 → 0.2.0

package/dist/node_modules/@tiptap/core/dist/jsx-runtime/jsx-runtime.js

@@ -0,0 +1,17 @@
+var t = (e, n) => {
+  if (e === "slot")
+    return 0;
+  if (e instanceof Function)
+    return e(n);
+  const { children: r, ...s } = n ?? {};
+  if (e === "svg")
+    throw new Error("SVG elements are not supported in the JSX syntax, use the array syntax instead");
+  return [e, s, r];
+};
+export {
+  t as createElement,
+  t as h,
+  t as jsx,
+  t as jsxDEV,
+  t as jsxs
+};

package/dist/node_modules/@tiptap/extension-bold/dist/index.js

@@ -0,0 +1,80 @@
+import { Mark as a, markPasteRule as r, markInputRule as s, mergeAttributes as d } from "../../core/dist/index.js";
+import { createElement as n } from "../../core/dist/jsx-runtime/jsx-runtime.js";
+var o = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, l = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g, u = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/, i = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g, g = a.create({
+  name: "bold",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "strong"
+      },
+      {
+        tag: "b",
+        getAttrs: (e) => e.style.fontWeight !== "normal" && null
+      },
+      {
+        style: "font-weight=400",
+        clearMark: (e) => e.type.name === this.name
+      },
+      {
+        style: "font-weight",
+        getAttrs: (e) => /^(bold(er)?|[5-9]\d{2,})$/.test(e) && null
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return /* @__PURE__ */ n("strong", { ...d(this.options.HTMLAttributes, e), children: /* @__PURE__ */ n("slot", {}) });
+  },
+  markdownTokenName: "strong",
+  parseMarkdown: (e, t) => t.applyMark("bold", t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => `**${t.renderChildren(e)}**`,
+  addCommands() {
+    return {
+      setBold: () => ({ commands: e }) => e.setMark(this.name),
+      toggleBold: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetBold: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-b": () => this.editor.commands.toggleBold(),
+      "Mod-B": () => this.editor.commands.toggleBold()
+    };
+  },
+  addInputRules() {
+    return [
+      s({
+        find: o,
+        type: this.type
+      }),
+      s({
+        find: u,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      r({
+        find: l,
+        type: this.type
+      }),
+      r({
+        find: i,
+        type: this.type
+      })
+    ];
+  }
+}), _ = g;
+export {
+  g as Bold,
+  _ as default,
+  o as starInputRegex,
+  l as starPasteRegex,
+  u as underscoreInputRegex,
+  i as underscorePasteRegex
+};

package/dist/node_modules/@tiptap/extension-document/dist/index.js

@@ -0,0 +1,13 @@
+import { Node as n } from "../../core/dist/index.js";
+var t = n.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+",
+  renderMarkdown: (e, r) => e.content ? r.renderChildren(e.content, `
+
+`) : ""
+}), d = t;
+export {
+  t as Document,
+  d as default
+};

package/dist/node_modules/@tiptap/extension-heading/dist/index.js

@@ -0,0 +1,64 @@
+import { Node as l, textblockTypeInputRule as a, mergeAttributes as i } from "../../core/dist/index.js";
+var o = l.create({
+  name: "heading",
+  addOptions() {
+    return {
+      levels: [1, 2, 3, 4, 5, 6],
+      HTMLAttributes: {}
+    };
+  },
+  content: "inline*",
+  group: "block",
+  defining: !0,
+  addAttributes() {
+    return {
+      level: {
+        default: 1,
+        rendered: !1
+      }
+    };
+  },
+  parseHTML() {
+    return this.options.levels.map((e) => ({
+      tag: `h${e}`,
+      attrs: { level: e }
+    }));
+  },
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [`h${this.options.levels.includes(e.attrs.level) ? e.attrs.level : this.options.levels[0]}`, i(this.options.HTMLAttributes, t), 0];
+  },
+  parseMarkdown: (e, t) => t.createNode("heading", { level: e.depth || 1 }, t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => {
+    var r;
+    const n = (r = e.attrs) != null && r.level ? parseInt(e.attrs.level, 10) : 1, s = "#".repeat(n);
+    return e.content ? `${s} ${t.renderChildren(e.content)}` : "";
+  },
+  addCommands() {
+    return {
+      setHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.setNode(this.name, e) : !1,
+      toggleHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.toggleNode(this.name, "paragraph", e) : !1
+    };
+  },
+  addKeyboardShortcuts() {
+    return this.options.levels.reduce(
+      (e, t) => ({
+        ...e,
+        [`Mod-Alt-${t}`]: () => this.editor.commands.toggleHeading({ level: t })
+      }),
+      {}
+    );
+  },
+  addInputRules() {
+    return this.options.levels.map((e) => a({
+      find: new RegExp(`^(#{${Math.min(...this.options.levels)},${e}})\\s$`),
+      type: this.type,
+      getAttributes: {
+        level: e
+      }
+    }));
+  }
+}), u = o;
+export {
+  o as Heading,
+  u as default
+};

package/dist/node_modules/@tiptap/extension-italic/dist/index.js

@@ -0,0 +1,78 @@
+import { Mark as s, markPasteRule as r, markInputRule as a, mergeAttributes as n } from "../../core/dist/index.js";
+var i = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/, d = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g, l = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/, o = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g, u = s.create({
+  name: "italic",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "em"
+      },
+      {
+        tag: "i",
+        getAttrs: (t) => t.style.fontStyle !== "normal" && null
+      },
+      {
+        style: "font-style=normal",
+        clearMark: (t) => t.type.name === this.name
+      },
+      {
+        style: "font-style=italic"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["em", n(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setItalic: () => ({ commands: t }) => t.setMark(this.name),
+      toggleItalic: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetItalic: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  markdownTokenName: "em",
+  parseMarkdown: (t, e) => e.applyMark("italic", e.parseInline(t.tokens || [])),
+  renderMarkdown: (t, e) => `*${e.renderChildren(t)}*`,
+  addKeyboardShortcuts() {
+    return {
+      "Mod-i": () => this.editor.commands.toggleItalic(),
+      "Mod-I": () => this.editor.commands.toggleItalic()
+    };
+  },
+  addInputRules() {
+    return [
+      a({
+        find: i,
+        type: this.type
+      }),
+      a({
+        find: l,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      r({
+        find: d,
+        type: this.type
+      }),
+      r({
+        find: o,
+        type: this.type
+      })
+    ];
+  }
+}), p = u;
+export {
+  u as Italic,
+  p as default,
+  i as starInputRegex,
+  d as starPasteRegex,
+  l as underscoreInputRegex,
+  o as underscorePasteRegex
+};

package/dist/node_modules/@tiptap/extension-link/dist/index.js

@@ -0,0 +1,305 @@
+import { Mark as y, markPasteRule as b, mergeAttributes as v, combineTransactionSteps as w, getChangedRanges as T, findChildrenInRange as O, getMarksBetween as _, getAttributes as R } from "../../core/dist/index.js";
+import { find as M, registerCustomProtocol as C, tokenize as H, reset as I } from "../../../linkifyjs/dist/linkify.js";
+import { Plugin as g, PluginKey as A } from "../../../prosemirror-state/dist/index.js";
+var P = "[\0-   ᠎ -\u2029 　]", B = new RegExp(P), U = new RegExp(`${P}$`), N = new RegExp(P, "g");
+function V(t) {
+  return t.length === 1 ? t[0].isLink : t.length === 3 && t[1].isLink ? ["()", "[]"].includes(t[0].value + t[2].value) : !1;
+}
+function W(t) {
+  return new g({
+    key: new A("autolink"),
+    appendTransaction: (e, r, o) => {
+      const i = e.some((s) => s.docChanged) && !r.doc.eq(o.doc), l = e.some((s) => s.getMeta("preventAutolink"));
+      if (!i || l)
+        return;
+      const { tr: d } = o, a = w(r.doc, [...e]);
+      if (T(a).forEach(({ newRange: s }) => {
+        const f = O(o.doc, s, (c) => c.isTextblock);
+        let u, p;
+        if (f.length > 1)
+          u = f[0], p = o.doc.textBetween(
+            u.pos,
+            u.pos + u.node.nodeSize,
+            void 0,
+            " "
+          );
+        else if (f.length) {
+          const c = o.doc.textBetween(s.from, s.to, " ", " ");
+          if (!U.test(c))
+            return;
+          u = f[0], p = o.doc.textBetween(u.pos, s.to, void 0, " ");
+        }
+        if (u && p) {
+          const c = p.split(B).filter(Boolean);
+          if (c.length <= 0)
+            return !1;
+          const m = c[c.length - 1], E = u.pos + p.lastIndexOf(m);
+          if (!m)
+            return !1;
+          const L = H(m).map((n) => n.toObject(t.defaultProtocol));
+          if (!V(L))
+            return !1;
+          L.filter((n) => n.isLink).map((n) => ({
+            ...n,
+            from: E + n.start + 1,
+            to: E + n.end + 1
+          })).filter((n) => o.schema.marks.code ? !o.doc.rangeHasMark(n.from, n.to, o.schema.marks.code) : !0).filter((n) => t.validate(n.value)).filter((n) => t.shouldAutoLink(n.value)).forEach((n) => {
+            _(n.from, n.to, o.doc).some((x) => x.mark.type === t.type) || d.addMark(
+              n.from,
+              n.to,
+              t.type.create({
+                href: n.href
+              })
+            );
+          });
+        }
+      }), !!d.steps.length)
+        return d;
+    }
+  });
+}
+function D(t) {
+  return new g({
+    key: new A("handleClickLink"),
+    props: {
+      handleClick: (e, r, o) => {
+        var i, l;
+        if (o.button !== 0 || !e.editable)
+          return !1;
+        let d = !1;
+        if (t.enableClickSelection && (d = t.editor.commands.extendMarkRange(t.type.name)), t.openOnClick) {
+          let a = null;
+          if (o.target instanceof HTMLAnchorElement)
+            a = o.target;
+          else {
+            let u = o.target;
+            const p = [];
+            for (; u.nodeName !== "DIV"; )
+              p.push(u), u = u.parentNode;
+            a = p.find((c) => c.nodeName === "A");
+          }
+          if (!a)
+            return d;
+          const h = R(e.state, t.type.name), s = (i = a?.href) != null ? i : h.href, f = (l = a?.target) != null ? l : h.target;
+          a && s && (window.open(s, f), d = !0);
+        }
+        return d;
+      }
+    }
+  });
+}
+function $(t) {
+  return new g({
+    key: new A("handlePasteLink"),
+    props: {
+      handlePaste: (e, r, o) => {
+        const { shouldAutoLink: i } = t, { state: l } = e, { selection: d } = l, { empty: a } = d;
+        if (a)
+          return !1;
+        let h = "";
+        o.content.forEach((f) => {
+          h += f.textContent;
+        });
+        const s = M(h, { defaultProtocol: t.defaultProtocol }).find(
+          (f) => f.isLink && f.value === h
+        );
+        return !h || !s || i !== void 0 && !i(s.href) ? !1 : t.editor.commands.setMark(t.type, {
+          href: s.href
+        });
+      }
+    }
+  });
+}
+function k(t, e) {
+  const r = ["http", "https", "ftp", "ftps", "mailto", "tel", "callto", "sms", "cid", "xmpp"];
+  return e && e.forEach((o) => {
+    const i = typeof o == "string" ? o : o.scheme;
+    i && r.push(i);
+  }), !t || t.replace(N, "").match(
+    new RegExp(
+      // eslint-disable-next-line no-useless-escape
+      `^(?:(?:${r.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
+      "i"
+    )
+  );
+}
+var z = y.create({
+  name: "link",
+  priority: 1e3,
+  keepOnSplit: !1,
+  exitable: !0,
+  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") {
+        C(t);
+        return;
+      }
+      C(t.scheme, t.optionalSlashes);
+    });
+  },
+  onDestroy() {
+    I();
+  },
+  inclusive() {
+    return this.options.autolink;
+  },
+  addOptions() {
+    return {
+      openOnClick: !0,
+      enableClickSelection: !1,
+      linkOnPaste: !0,
+      autolink: !0,
+      protocols: [],
+      defaultProtocol: "http",
+      HTMLAttributes: {
+        target: "_blank",
+        rel: "noopener noreferrer nofollow",
+        class: null
+      },
+      isAllowedUri: (t, e) => !!k(t, e.protocols),
+      validate: (t) => !!t,
+      shouldAutoLink: (t) => !!t
+    };
+  },
+  addAttributes() {
+    return {
+      href: {
+        default: null,
+        parseHTML(t) {
+          return t.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: (t) => {
+          const e = t.getAttribute("href");
+          return !e || !this.options.isAllowedUri(e, {
+            defaultValidate: (r) => !!k(r, this.options.protocols),
+            protocols: this.options.protocols,
+            defaultProtocol: this.options.defaultProtocol
+          }) ? !1 : null;
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return this.options.isAllowedUri(t.href, {
+      defaultValidate: (e) => !!k(e, 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];
+  },
+  markdownTokenName: "link",
+  parseMarkdown: (t, e) => e.applyMark("link", e.parseInline(t.tokens || []), {
+    href: t.href,
+    title: t.title || null
+  }),
+  renderMarkdown: (t, e) => {
+    var r;
+    const o = ((r = t.attrs) == null ? void 0 : r.href) || "";
+    return `[${e.renderChildren(t)}](${o})`;
+  },
+  addCommands() {
+    return {
+      setLink: (t) => ({ chain: e }) => {
+        const { href: r } = t;
+        return this.options.isAllowedUri(r, {
+          defaultValidate: (o) => !!k(o, this.options.protocols),
+          protocols: this.options.protocols,
+          defaultProtocol: this.options.defaultProtocol
+        }) ? e().setMark(this.name, t).setMeta("preventAutolink", !0).run() : !1;
+      },
+      toggleLink: (t) => ({ chain: e }) => {
+        const { href: r } = t || {};
+        return r && !this.options.isAllowedUri(r, {
+          defaultValidate: (o) => !!k(o, this.options.protocols),
+          protocols: this.options.protocols,
+          defaultProtocol: this.options.defaultProtocol
+        }) ? !1 : e().toggleMark(this.name, t, { extendEmptyMarkRange: !0 }).setMeta("preventAutolink", !0).run();
+      },
+      unsetLink: () => ({ chain: t }) => t().unsetMark(this.name, { extendEmptyMarkRange: !0 }).setMeta("preventAutolink", !0).run()
+    };
+  },
+  addPasteRules() {
+    return [
+      b({
+        find: (t) => {
+          const e = [];
+          if (t) {
+            const { protocols: r, defaultProtocol: o } = this.options, i = M(t).filter(
+              (l) => l.isLink && this.options.isAllowedUri(l.value, {
+                defaultValidate: (d) => !!k(d, r),
+                protocols: r,
+                defaultProtocol: o
+              })
+            );
+            i.length && i.forEach((l) => {
+              this.options.shouldAutoLink(l.value) && e.push({
+                text: l.value,
+                data: {
+                  href: l.href
+                },
+                index: l.start
+              });
+            });
+          }
+          return e;
+        },
+        type: this.type,
+        getAttributes: (t) => {
+          var e;
+          return {
+            href: (e = t.data) == null ? void 0 : e.href
+          };
+        }
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    const t = [], { protocols: e, defaultProtocol: r } = this.options;
+    return this.options.autolink && t.push(
+      W({
+        type: this.type,
+        defaultProtocol: this.options.defaultProtocol,
+        validate: (o) => this.options.isAllowedUri(o, {
+          defaultValidate: (i) => !!k(i, e),
+          protocols: e,
+          defaultProtocol: r
+        }),
+        shouldAutoLink: this.options.shouldAutoLink
+      })
+    ), t.push(
+      D({
+        type: this.type,
+        editor: this.editor,
+        openOnClick: this.options.openOnClick === "whenNotEditable" ? !0 : this.options.openOnClick,
+        enableClickSelection: this.options.enableClickSelection
+      })
+    ), this.options.linkOnPaste && t.push(
+      $({
+        editor: this.editor,
+        defaultProtocol: this.options.defaultProtocol,
+        type: this.type,
+        shouldAutoLink: this.options.shouldAutoLink
+      })
+    ), t;
+  }
+}), j = z;
+export {
+  z as Link,
+  j as default,
+  k as isAllowedUri
+};