@vc-shell/framework 1.1.75 → 1.1.77

package/dist/vendor-tiptap-extension-blockquote-25QerT8O.js

@@ -0,0 +1,41 @@
+import { N as r, w as o, h as e, m as n } from "./vendor-tiptap-core-CtNT-ozM.js";
+var u = /^\s*>\s$/, a = r.create({
+  name: "blockquote",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  group: "block",
+  defining: !0,
+  parseHTML() {
+    return [{ tag: "blockquote" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return /* @__PURE__ */ e("blockquote", { ...n(this.options.HTMLAttributes, t), children: /* @__PURE__ */ e("slot", {}) });
+  },
+  addCommands() {
+    return {
+      setBlockquote: () => ({ commands: t }) => t.wrapIn(this.name),
+      toggleBlockquote: () => ({ commands: t }) => t.toggleWrap(this.name),
+      unsetBlockquote: () => ({ commands: t }) => t.lift(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+    };
+  },
+  addInputRules() {
+    return [
+      o({
+        find: u,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  a as B
+};

package/dist/vendor-tiptap-extension-bold-B-B75KIy.js

@@ -0,0 +1,71 @@
+import { M as a, a as e, b as r, h as s, m as n } from "./vendor-tiptap-core-CtNT-ozM.js";
+var o = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, d = /(?:^|\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: (t) => t.style.fontWeight !== "normal" && null
+      },
+      {
+        style: "font-weight=400",
+        clearMark: (t) => t.type.name === this.name
+      },
+      {
+        style: "font-weight",
+        getAttrs: (t) => /^(bold(er)?|[5-9]\d{2,})$/.test(t) && null
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return /* @__PURE__ */ s("strong", { ...n(this.options.HTMLAttributes, t), children: /* @__PURE__ */ s("slot", {}) });
+  },
+  addCommands() {
+    return {
+      setBold: () => ({ commands: t }) => t.setMark(this.name),
+      toggleBold: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetBold: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-b": () => this.editor.commands.toggleBold(),
+      "Mod-B": () => this.editor.commands.toggleBold()
+    };
+  },
+  addInputRules() {
+    return [
+      r({
+        find: o,
+        type: this.type
+      }),
+      r({
+        find: u,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      e({
+        find: d,
+        type: this.type
+      }),
+      e({
+        find: i,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  g as B
+};

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

@@ -0,0 +1,49 @@
+import { M as t, a as r, b as a, m as s } from "./vendor-tiptap-core-CtNT-ozM.js";
+var d = /(^|[^`])`([^`]+)`(?!`)$/, n = /(^|[^`])`([^`]+)`(?!`)/g, o = t.create({
+  name: "code",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  excludes: "_",
+  code: !0,
+  exitable: !0,
+  parseHTML() {
+    return [{ tag: "code" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["code", s(this.options.HTMLAttributes, e), 0];
+  },
+  addCommands() {
+    return {
+      setCode: () => ({ commands: e }) => e.setMark(this.name),
+      toggleCode: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetCode: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-e": () => this.editor.commands.toggleCode()
+    };
+  },
+  addInputRules() {
+    return [
+      a({
+        find: d,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      r({
+        find: n,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  o as C
+};

package/dist/vendor-tiptap-extension-code-block-BFDiCj59.js

@@ -0,0 +1,192 @@
+import { N as T, t as b, m as v } from "./vendor-tiptap-core-CtNT-ozM.js";
+import { P as A, a as C, T as y, S as k } from "./vendor-prosemirror-state-6jGEPgrP.js";
+var L = /^```([a-z]+)?[\s\n]$/, P = /^~~~([a-z]+)?[\s\n]$/, D = T.create({
+  name: "codeBlock",
+  addOptions() {
+    return {
+      languageClassPrefix: "language-",
+      exitOnTripleEnter: !0,
+      exitOnArrowDown: !0,
+      defaultLanguage: null,
+      enableTabIndentation: !1,
+      tabSize: 4,
+      HTMLAttributes: {}
+    };
+  },
+  content: "text*",
+  marks: "",
+  group: "block",
+  code: !0,
+  defining: !0,
+  addAttributes() {
+    return {
+      language: {
+        default: this.options.defaultLanguage,
+        parseHTML: (e) => {
+          var t;
+          const { languageClassPrefix: a } = this.options, r = [...((t = e.firstElementChild) == null ? void 0 : t.classList) || []].filter((n) => n.startsWith(a)).map((n) => n.replace(a, ""))[0];
+          return r || null;
+        },
+        rendered: !1
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "pre",
+        preserveWhitespace: "full"
+      }
+    ];
+  },
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [
+      "pre",
+      v(this.options.HTMLAttributes, t),
+      [
+        "code",
+        {
+          class: e.attrs.language ? this.options.languageClassPrefix + e.attrs.language : null
+        },
+        0
+      ]
+    ];
+  },
+  addCommands() {
+    return {
+      setCodeBlock: (e) => ({ commands: t }) => t.setNode(this.name, e),
+      toggleCodeBlock: (e) => ({ commands: t }) => t.toggleNode(this.name, "paragraph", e)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
+      // remove code block when at start of document or code block is empty
+      Backspace: () => {
+        const { empty: e, $anchor: t } = this.editor.state.selection, a = t.pos === 1;
+        return !e || t.parent.type.name !== this.name ? !1 : a || !t.parent.textContent.length ? this.editor.commands.clearNodes() : !1;
+      },
+      // handle tab indentation
+      Tab: ({ editor: e }) => {
+        if (!this.options.enableTabIndentation)
+          return !1;
+        const { state: t } = e, { selection: a } = t, { $from: s, empty: i } = a;
+        if (s.parent.type !== this.type)
+          return !1;
+        const r = " ".repeat(this.options.tabSize);
+        return i ? e.commands.insertContent(r) : e.commands.command(({ tr: n }) => {
+          const { from: o, to: c } = a, l = t.doc.textBetween(o, c, `
+`, `
+`).split(`
+`).map((d) => r + d).join(`
+`);
+          return n.replaceWith(o, c, t.schema.text(l)), !0;
+        });
+      },
+      // handle shift+tab reverse indentation
+      "Shift-Tab": ({ editor: e }) => {
+        if (!this.options.enableTabIndentation)
+          return !1;
+        const { state: t } = e, { selection: a } = t, { $from: s, empty: i } = a;
+        return s.parent.type !== this.type ? !1 : i ? e.commands.command(({ tr: r }) => {
+          var n;
+          const { pos: o } = s, c = s.start(), p = s.end(), l = t.doc.textBetween(c, p, `
+`, `
+`).split(`
+`);
+          let d = 0, m = 0;
+          const h = o - c;
+          for (let u = 0; u < l.length; u += 1) {
+            if (m + l[u].length >= h) {
+              d = u;
+              break;
+            }
+            m += l[u].length + 1;
+          }
+          const S = ((n = l[d].match(/^ */)) == null ? void 0 : n[0]) || "", x = Math.min(S.length, this.options.tabSize);
+          if (x === 0)
+            return !0;
+          let f = c;
+          for (let u = 0; u < d; u += 1)
+            f += l[u].length + 1;
+          return r.delete(f, f + x), o - f <= x && r.setSelection(y.create(r.doc, f)), !0;
+        }) : e.commands.command(({ tr: r }) => {
+          const { from: n, to: o } = a, g = t.doc.textBetween(n, o, `
+`, `
+`).split(`
+`).map((l) => {
+            var d;
+            const m = ((d = l.match(/^ */)) == null ? void 0 : d[0]) || "", h = Math.min(m.length, this.options.tabSize);
+            return l.slice(h);
+          }).join(`
+`);
+          return r.replaceWith(n, o, t.schema.text(g)), !0;
+        });
+      },
+      // exit node on triple enter
+      Enter: ({ editor: e }) => {
+        if (!this.options.exitOnTripleEnter)
+          return !1;
+        const { state: t } = e, { selection: a } = t, { $from: s, empty: i } = a;
+        if (!i || s.parent.type !== this.type)
+          return !1;
+        const r = s.parentOffset === s.parent.nodeSize - 2, n = s.parent.textContent.endsWith(`
+
+`);
+        return !r || !n ? !1 : e.chain().command(({ tr: o }) => (o.delete(s.pos - 2, s.pos), !0)).exitCode().run();
+      },
+      // exit node on arrow down
+      ArrowDown: ({ editor: e }) => {
+        if (!this.options.exitOnArrowDown)
+          return !1;
+        const { state: t } = e, { selection: a, doc: s } = t, { $from: i, empty: r } = a;
+        if (!r || i.parent.type !== this.type || !(i.parentOffset === i.parent.nodeSize - 2))
+          return !1;
+        const o = i.after();
+        return o === void 0 ? !1 : s.nodeAt(o) ? e.commands.command(({ tr: p }) => (p.setSelection(k.near(s.resolve(o))), !0)) : e.commands.exitCode();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      b({
+        find: L,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      }),
+      b({
+        find: P,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      // this plugin creates a code block for pasted content from VS Code
+      // we can also detect the copied code language
+      new A({
+        key: new C("codeBlockVSCodeHandler"),
+        props: {
+          handlePaste: (e, t) => {
+            if (!t.clipboardData || this.editor.isActive(this.type.name))
+              return !1;
+            const a = t.clipboardData.getData("text/plain"), s = t.clipboardData.getData("vscode-editor-data"), i = s ? JSON.parse(s) : void 0, r = i?.mode;
+            if (!a || !r)
+              return !1;
+            const { tr: n, schema: o } = e.state, c = o.text(a.replace(/\r\n?/g, `
+`));
+            return n.replaceSelectionWith(this.type.create({ language: r }, c)), n.selection.$from.parent.type !== this.type && n.setSelection(y.near(n.doc.resolve(Math.max(0, n.selection.from - 2)))), n.setMeta("paste", !0), e.dispatch(n), !0;
+          }
+        }
+      })
+    ];
+  }
+});
+export {
+  D as C
+};

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

@@ -0,0 +1,9 @@
+import { N as o } from "./vendor-tiptap-core-CtNT-ozM.js";
+var t = o.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+"
+});
+export {
+  t as D
+};

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

@@ -0,0 +1,53 @@
+import { N as l, m as c } from "./vendor-tiptap-core-CtNT-ozM.js";
+var M = l.create({
+  name: "hardBreak",
+  addOptions() {
+    return {
+      keepMarks: !0,
+      HTMLAttributes: {}
+    };
+  },
+  inline: !0,
+  group: "inline",
+  selectable: !1,
+  linebreakReplacement: !0,
+  parseHTML() {
+    return [{ tag: "br" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["br", c(this.options.HTMLAttributes, e)];
+  },
+  renderText() {
+    return `
+`;
+  },
+  addCommands() {
+    return {
+      setHardBreak: () => ({ commands: e, chain: n, state: s, editor: a }) => e.first([
+        () => e.exitCode(),
+        () => e.command(() => {
+          const { selection: r, storedMarks: i } = s;
+          if (r.$from.parent.type.spec.isolating)
+            return !1;
+          const { keepMarks: o } = this.options, { splittableMarks: d } = a.extensionManager, t = i || r.$to.parentOffset && r.$from.marks();
+          return n().insertContent({ type: this.name }).command(({ tr: u, dispatch: m }) => {
+            if (m && t && o) {
+              const p = t.filter((k) => d.includes(k.type.name));
+              u.ensureMarks(p);
+            }
+            return !0;
+          }).run();
+        })
+      ])
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Enter": () => this.editor.commands.setHardBreak(),
+      "Shift-Enter": () => this.editor.commands.setHardBreak()
+    };
+  }
+});
+export {
+  M as H
+};

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

@@ -0,0 +1,57 @@
+import { N as s, t as n, m as r } from "./vendor-tiptap-core-CtNT-ozM.js";
+var a = s.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]}`, r(this.options.HTMLAttributes, t), 0];
+  },
+  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) => n({
+      find: new RegExp(`^(#{${Math.min(...this.options.levels)},${e}})\\s$`),
+      type: this.type,
+      getAttributes: {
+        level: e
+      }
+    }));
+  }
+});
+export {
+  a as H
+};

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

@@ -0,0 +1,53 @@
+import { N as p, n as f, c as m, i as h, m as T } from "./vendor-tiptap-core-CtNT-ozM.js";
+import { T as r, N as A } from "./vendor-prosemirror-state-6jGEPgrP.js";
+var y = p.create({
+  name: "horizontalRule",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  parseHTML() {
+    return [{ tag: "hr" }];
+  },
+  renderHTML({ HTMLAttributes: n }) {
+    return ["hr", T(this.options.HTMLAttributes, n)];
+  },
+  addCommands() {
+    return {
+      setHorizontalRule: () => ({ chain: n, state: o }) => {
+        if (!m(o, o.schema.nodes[this.name]))
+          return !1;
+        const { selection: i } = o, { $to: d } = i, s = n();
+        return h(i) ? s.insertContentAt(d.pos, {
+          type: this.name
+        }) : s.insertContent({ type: this.name }), s.command(({ tr: e, dispatch: u }) => {
+          var a;
+          if (u) {
+            const { $to: t } = e.selection, c = t.end();
+            if (t.nodeAfter)
+              t.nodeAfter.isTextblock ? e.setSelection(r.create(e.doc, t.pos + 1)) : t.nodeAfter.isBlock ? e.setSelection(A.create(e.doc, t.pos)) : e.setSelection(r.create(e.doc, t.pos));
+            else {
+              const l = (a = t.parent.type.contentMatch.defaultType) == null ? void 0 : a.create();
+              l && (e.insert(c, l), e.setSelection(r.create(e.doc, c + 1)));
+            }
+            e.scrollIntoView();
+          }
+          return !0;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      f({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  y as H
+};

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

@@ -0,0 +1,70 @@
+import { N as i, n as s, m as a } from "./vendor-tiptap-core-CtNT-ozM.js";
+var l = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/, o = i.create({
+  name: "image",
+  addOptions() {
+    return {
+      inline: !1,
+      allowBase64: !1,
+      HTMLAttributes: {}
+    };
+  },
+  inline() {
+    return this.options.inline;
+  },
+  group() {
+    return this.options.inline ? "inline" : "block";
+  },
+  draggable: !0,
+  addAttributes() {
+    return {
+      src: {
+        default: null
+      },
+      alt: {
+        default: null
+      },
+      title: {
+        default: null
+      },
+      width: {
+        default: null
+      },
+      height: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: this.options.allowBase64 ? "img[src]" : 'img[src]:not([src^="data:"])'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["img", a(this.options.HTMLAttributes, t)];
+  },
+  addCommands() {
+    return {
+      setImage: (t) => ({ commands: e }) => e.insertContent({
+        type: this.name,
+        attrs: t
+      })
+    };
+  },
+  addInputRules() {
+    return [
+      s({
+        find: l,
+        type: this.type,
+        getAttributes: (t) => {
+          const [, , e, n, r] = t;
+          return { src: n, alt: e, title: r };
+        }
+      })
+    ];
+  }
+});
+export {
+  o as I
+};

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

@@ -0,0 +1,70 @@
+import { M as r, a as e, b as s, m as a } from "./vendor-tiptap-core-CtNT-ozM.js";
+var n = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/, i = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g, l = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/, u = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g, d = r.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", a(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)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-i": () => this.editor.commands.toggleItalic(),
+      "Mod-I": () => this.editor.commands.toggleItalic()
+    };
+  },
+  addInputRules() {
+    return [
+      s({
+        find: n,
+        type: this.type
+      }),
+      s({
+        find: l,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      e({
+        find: i,
+        type: this.type
+      }),
+      e({
+        find: u,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  d as I
+};