@caspeco/casper-ui-library 9.9.0 → 9.10.0

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

@@ -0,0 +1,49 @@
+import { Node as d, mergeAttributes as u } from "../../core/dist/index.js";
+var n = " ", p = " ", l = d.create({
+  name: "paragraph",
+  priority: 1e3,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [{ tag: "p" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["p", u(this.options.HTMLAttributes, t), 0];
+  },
+  parseMarkdown: (t, a) => {
+    const r = t.tokens || [];
+    if (r.length === 1 && r[0].type === "image")
+      return a.parseChildren([r[0]]);
+    const e = a.parseInline(r);
+    return r.length === 1 && r[0].type === "text" && (r[0].raw === n || r[0].text === n || r[0].raw === p || r[0].text === p) && e.length === 1 && e[0].type === "text" && (e[0].text === n || e[0].text === p) ? a.createNode("paragraph", void 0, []) : a.createNode("paragraph", void 0, e);
+  },
+  renderMarkdown: (t, a, r) => {
+    var e, o;
+    if (!t)
+      return "";
+    const i = Array.isArray(t.content) ? t.content : [];
+    if (i.length === 0) {
+      const s = Array.isArray((e = r?.previousNode) == null ? void 0 : e.content) ? r.previousNode.content : [];
+      return ((o = r?.previousNode) == null ? void 0 : o.type) === "paragraph" && s.length === 0 ? n : "";
+    }
+    return a.renderChildren(i);
+  },
+  addCommands() {
+    return {
+      setParagraph: () => ({ commands: t }) => t.setNode(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+    };
+  }
+});
+export {
+  l as Paragraph
+};

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

@@ -0,0 +1,66 @@
+import { Mark as r, markPasteRule as s, markInputRule as n, mergeAttributes as a } from "../../core/dist/index.js";
+var i = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, d = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, o = r.create({
+  name: "strike",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "s"
+      },
+      {
+        tag: "del"
+      },
+      {
+        tag: "strike"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (e) => e.includes("line-through") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["s", a(this.options.HTMLAttributes, e), 0];
+  },
+  markdownTokenName: "del",
+  parseMarkdown: (e, t) => t.applyMark("strike", t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => `~~${t.renderChildren(e)}~~`,
+  addCommands() {
+    return {
+      setStrike: () => ({ commands: e }) => e.setMark(this.name),
+      toggleStrike: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetStrike: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-s": () => this.editor.commands.toggleStrike()
+    };
+  },
+  addInputRules() {
+    return [
+      n({
+        find: i,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      s({
+        find: d,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  o as Strike,
+  i as inputRegex,
+  d as pasteRegex
+};

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

@@ -0,0 +1,13 @@
+import { Node as t } from "../../core/dist/index.js";
+var o = t.create({
+  name: "text",
+  group: "inline",
+  parseMarkdown: (e) => ({
+    type: "text",
+    text: e.text || ""
+  }),
+  renderMarkdown: (e) => e.text || ""
+});
+export {
+  o as Text
+};

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

@@ -0,0 +1,65 @@
+import { Mark as s, mergeAttributes as d } from "../../core/dist/index.js";
+var u = s.create({
+  name: "underline",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "u"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (e) => e.includes("underline") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["u", d(this.options.HTMLAttributes, e), 0];
+  },
+  parseMarkdown(e, n) {
+    return n.applyMark(this.name || "underline", n.parseInline(e.tokens || []));
+  },
+  renderMarkdown(e, n) {
+    return `++${n.renderChildren(e)}++`;
+  },
+  markdownTokenizer: {
+    name: "underline",
+    level: "inline",
+    start(e) {
+      return e.indexOf("++");
+    },
+    tokenize(e, n, i) {
+      const r = /^(\+\+)([\s\S]+?)(\+\+)/.exec(e);
+      if (!r)
+        return;
+      const t = r[2].trim();
+      return {
+        type: "underline",
+        raw: r[0],
+        text: t,
+        tokens: i.inlineTokens(t)
+      };
+    }
+  },
+  addCommands() {
+    return {
+      setUnderline: () => ({ commands: e }) => e.setMark(this.name),
+      toggleUnderline: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetUnderline: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-u": () => this.editor.commands.toggleUnderline(),
+      "Mod-U": () => this.editor.commands.toggleUnderline()
+    };
+  }
+});
+export {
+  u as Underline
+};

package/dist/node_modules/@tiptap/extensions/dist/index.js

@@ -0,0 +1,439 @@
+import { Extension as h, callOrReturn as M, getExtensionField as A, isNodeEmpty as v, isNodeSelection as x } from "../../core/dist/index.js";
+import { PluginKey as y, Plugin as C } from "../../../prosemirror-state/dist/index.js";
+import { dropCursor as R } from "../../../prosemirror-dropcursor/dist/index.js";
+import { DecorationSet as P, Decoration as w } from "../../../prosemirror-view/dist/index.js";
+import { gapCursor as _ } from "../../../prosemirror-gapcursor/dist/index.js";
+import { history as O, redo as D, undo as L } from "../../../prosemirror-history/dist/index.js";
+h.create({
+  name: "characterCount",
+  addOptions() {
+    return {
+      limit: null,
+      autoTrim: !0,
+      mode: "textSize",
+      textCounter: (e) => e.length,
+      wordCounter: (e) => e.split(" ").filter((t) => t !== "").length
+    };
+  },
+  addStorage() {
+    return {
+      characters: () => 0,
+      words: () => 0
+    };
+  },
+  onBeforeCreate() {
+    this.storage.characters = (e) => {
+      const t = e?.node || this.editor.state.doc;
+      if ((e?.mode || this.options.mode) === "textSize") {
+        const n = t.textBetween(0, t.content.size, void 0, " ");
+        return this.options.textCounter(n);
+      }
+      return t.nodeSize;
+    }, this.storage.words = (e) => {
+      const t = e?.node || this.editor.state.doc, o = t.textBetween(0, t.content.size, " ", " ");
+      return this.options.wordCounter(o);
+    };
+  },
+  addProseMirrorPlugins() {
+    let e = !1;
+    return [
+      new C({
+        key: new y("characterCount"),
+        appendTransaction: (t, o, n) => {
+          if (e)
+            return;
+          const r = this.options.limit, s = this.options.autoTrim;
+          if (r == null || r === 0 || s === !1) {
+            e = !0;
+            return;
+          }
+          const i = this.storage.characters({ node: n.doc });
+          if (i > r) {
+            const d = i - r, a = 0, c = d;
+            console.warn(
+              `[CharacterCount] Initial content exceeded limit of ${r} characters. Content was automatically trimmed.`
+            );
+            const l = n.tr.deleteRange(a, c);
+            return e = !0, l;
+          }
+          e = !0;
+        },
+        filterTransaction: (t, o) => {
+          const n = this.options.limit;
+          if (!t.docChanged || n === 0 || n === null || n === void 0)
+            return !0;
+          const r = this.storage.characters({ node: o.doc }), s = this.storage.characters({ node: t.doc });
+          if (s <= n || r > n && s > n && s <= r)
+            return !0;
+          if (r > n && s > n && s > r || !t.getMeta("paste"))
+            return !1;
+          const d = t.selection.$head.pos, a = s - n, c = d - a, l = d;
+          return t.deleteRange(c, l), !(this.storage.characters({ node: t.doc }) > n);
+        }
+      })
+    ];
+  }
+});
+var V = h.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [R(this.options)];
+  }
+});
+h.create({
+  name: "focus",
+  addOptions() {
+    return {
+      className: "has-focus",
+      mode: "all"
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new C({
+        key: new y("focus"),
+        props: {
+          decorations: ({ doc: e, selection: t }) => {
+            const { isEditable: o, isFocused: n } = this.editor, { anchor: r } = t, s = [];
+            if (!o || !n)
+              return P.create(e, []);
+            let i = 0;
+            this.options.mode === "deepest" && e.descendants((a, c) => {
+              if (a.isText)
+                return;
+              if (!(r >= c && r <= c + a.nodeSize - 1))
+                return !1;
+              i += 1;
+            });
+            let d = 0;
+            return e.descendants((a, c) => {
+              if (a.isText || !(r >= c && r <= c + a.nodeSize - 1))
+                return !1;
+              if (d += 1, this.options.mode === "deepest" && i - d > 0 || this.options.mode === "shallowest" && d > 1)
+                return this.options.mode === "deepest";
+              s.push(
+                w.node(c, c + a.nodeSize, {
+                  class: this.options.className
+                })
+              );
+            }), P.create(e, s);
+          }
+        }
+      })
+    ];
+  }
+});
+var X = h.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [_()];
+  },
+  extendNodeSchema(e) {
+    var t;
+    const o = {
+      name: e.name,
+      options: e.options,
+      storage: e.storage
+    };
+    return {
+      allowGapCursor: (t = M(A(e, "allowGapCursor", o))) != null ? t : null
+    };
+  }
+});
+function S(e) {
+  const {
+    editor: t,
+    placeholder: o,
+    dataAttribute: n,
+    pos: r,
+    node: s,
+    isEmptyDoc: i,
+    hasAnchor: d,
+    classes: { emptyNode: a, emptyEditor: c }
+  } = e, l = [a];
+  return i && l.push(c), w.node(r, r + s.nodeSize, {
+    class: l.join(" "),
+    [n]: typeof o == "function" ? o({
+      editor: t,
+      node: s,
+      pos: r,
+      hasAnchor: d
+    }) : o
+  });
+}
+function k(e) {
+  const t = getComputedStyle(e), o = `${t.overflow} ${t.overflowY} ${t.overflowX}`;
+  return /auto|scroll|overlay/.test(o);
+}
+function B(e) {
+  let t = e;
+  for (; t; ) {
+    if (k(t))
+      return t;
+    const o = t.parentElement;
+    if (!o) {
+      const n = t.getRootNode();
+      if (n instanceof ShadowRoot) {
+        t = n.host;
+        continue;
+      }
+      return window;
+    }
+    t = o;
+  }
+  return window;
+}
+function $(e) {
+  return e === window ? { top: 0, bottom: window.innerHeight } : e.getBoundingClientRect();
+}
+function F({
+  doc: e,
+  view: t,
+  scrollContainer: o
+}) {
+  const n = t.dom.getBoundingClientRect(), r = o ? $(o) : { top: 0, bottom: window.innerHeight }, s = Math.max(n.top, r.top), i = Math.min(n.bottom, r.bottom);
+  if (s >= i)
+    return { top: 0, bottom: e.content.size };
+  const a = getComputedStyle(t.dom).direction === "rtl" ? Math.max(n.right - 2, n.left + 2) : n.left + 2, c = t.posAtCoords({ left: a, top: s + 2 }), l = t.posAtCoords({ left: a, top: i - 2 });
+  return {
+    top: c ? c.pos : 0,
+    bottom: l ? l.pos : e.content.size
+  };
+}
+function U(e, t) {
+  let o = null;
+  return { call: ((...s) => {
+    o || (e(...s), o = setTimeout(() => {
+      o = null;
+    }, t));
+  }), cancel: () => {
+    o && (clearTimeout(o), o = null);
+  } };
+}
+var T = "placeholder";
+function G(e) {
+  return e.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/^[0-9-]+/, "").replace(/^-+/, "").toLowerCase();
+}
+var g = new y("tiptap__placeholder");
+h.create({
+  name: "placeholder",
+  addOptions() {
+    return {
+      emptyEditorClass: "is-editor-empty",
+      emptyNodeClass: "is-empty",
+      dataAttribute: T,
+      placeholder: "Write something …",
+      showOnlyWhenEditable: !0,
+      showOnlyCurrent: !0,
+      includeChildren: !1
+    };
+  },
+  addProseMirrorPlugins() {
+    const e = this.options.dataAttribute ? `data-${G(this.options.dataAttribute)}` : `data-${T}`;
+    return [
+      new C({
+        state: {
+          init() {
+            return {
+              // null means "no viewport info yet" — decoration callback falls
+              // back to full document scan until the scroll handler fires.
+              topPos: null,
+              bottomPos: null
+            };
+          },
+          apply(t, o) {
+            const n = t.getMeta(g);
+            return n?.positions ? {
+              topPos: n.positions.top,
+              bottomPos: n.positions.bottom
+            } : t.docChanged ? {
+              topPos: o.topPos !== null ? t.mapping.map(o.topPos) : null,
+              bottomPos: o.bottomPos !== null ? t.mapping.map(o.bottomPos) : null
+            } : o;
+          }
+        },
+        key: g,
+        view(t) {
+          const o = B(t.dom), n = () => {
+            const d = F({
+              view: t,
+              doc: t.state.doc,
+              scrollContainer: o
+            }), a = g.getState(t.state);
+            if (a.topPos === d.top && a.bottomPos === d.bottom)
+              return;
+            const c = t.state.tr.setMeta(g, { positions: d }).setMeta("tiptap__viewportUpdate", !0);
+            t.dispatch(c);
+          }, { call: r, cancel: s } = U(n, 250), i = o;
+          return i.addEventListener("scroll", r, { passive: !0 }), n(), {
+            update(d, a) {
+              t.state.doc.content.size !== a.doc.content.size && n();
+            },
+            destroy: () => {
+              s(), i.removeEventListener("scroll", r);
+            }
+          };
+        },
+        props: {
+          decorations: ({ doc: t, selection: o }) => {
+            var n, r;
+            if (!(this.editor.isEditable || !this.options.showOnlyWhenEditable))
+              return null;
+            const { anchor: i } = o, d = [], a = this.editor.isEmpty;
+            if (this.options.showOnlyCurrent && !this.options.includeChildren) {
+              const l = t.resolve(i);
+              if (l.depth > 0) {
+                const u = l.node(1), m = l.before(1);
+                if (u.type.isTextblock && v(u)) {
+                  const p = i >= m && i <= m + u.nodeSize, f = S({
+                    node: u,
+                    dataAttribute: e,
+                    hasAnchor: p,
+                    placeholder: this.options.placeholder,
+                    classes: {
+                      emptyEditor: this.options.emptyEditorClass,
+                      emptyNode: this.options.emptyNodeClass
+                    },
+                    editor: this.editor,
+                    isEmptyDoc: a,
+                    pos: l.before(1)
+                  });
+                  d.push(f);
+                }
+              }
+            } else {
+              const l = g.getState(this.editor.state), u = (n = l.topPos) != null ? n : 0, m = (r = l.bottomPos) != null ? r : t.content.size;
+              t.nodesBetween(u, m, (p, f) => {
+                const b = i >= f && i <= f + p.nodeSize, z = !p.isLeaf && v(p);
+                if (!p.type.isTextblock)
+                  return this.options.includeChildren;
+                if ((b || !this.options.showOnlyCurrent) && z) {
+                  const N = S({
+                    classes: { emptyEditor: this.options.emptyEditorClass, emptyNode: this.options.emptyNodeClass },
+                    editor: this.editor,
+                    isEmptyDoc: a,
+                    dataAttribute: e,
+                    hasAnchor: b,
+                    placeholder: this.options.placeholder,
+                    node: p,
+                    pos: f
+                  });
+                  d.push(N);
+                }
+                return this.options.includeChildren;
+              });
+            }
+            return P.create(t, d);
+          }
+        }
+      })
+    ];
+  }
+});
+h.create({
+  name: "selection",
+  addOptions() {
+    return {
+      className: "selection"
+    };
+  },
+  addProseMirrorPlugins() {
+    const { editor: e, options: t } = this;
+    return [
+      new C({
+        key: new y("selection"),
+        props: {
+          decorations(o) {
+            return o.selection.empty || e.isFocused || !e.isEditable || x(o.selection) || e.view.dragging ? null : P.create(o.doc, [
+              w.inline(o.selection.from, o.selection.to, {
+                class: t.className
+              })
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+var I = "skipTrailingNode";
+function E({ types: e, node: t }) {
+  return t && Array.isArray(e) && e.includes(t.type) || t?.type === e;
+}
+var Z = h.create({
+  name: "trailingNode",
+  addOptions() {
+    return {
+      node: void 0,
+      notAfter: []
+    };
+  },
+  addProseMirrorPlugins() {
+    var e;
+    const t = new y(this.name), o = this.options.node || ((e = this.editor.schema.topNodeType.contentMatch.defaultType) == null ? void 0 : e.name) || "paragraph", n = Object.entries(this.editor.schema.nodes).map(([, r]) => r).filter((r) => (this.options.notAfter || []).concat(o).includes(r.name));
+    return [
+      new C({
+        key: t,
+        appendTransaction: (r, s, i) => {
+          const { doc: d, tr: a, schema: c } = i, l = t.getState(i), u = d.content.size, m = c.nodes[o];
+          if (!r.some((p) => p.getMeta(I)) && l)
+            return a.insert(u, m.create());
+        },
+        state: {
+          init: (r, s) => {
+            const i = s.tr.doc.lastChild;
+            return !E({ node: i, types: n });
+          },
+          apply: (r, s) => {
+            if (!r.docChanged || r.getMeta("__uniqueIDTransaction"))
+              return s;
+            const i = r.doc.lastChild;
+            return !E({ node: i, types: n });
+          }
+        }
+      })
+    ];
+  }
+}), J = h.create({
+  name: "undoRedo",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state: e, dispatch: t }) => L(e, t),
+      redo: () => ({ state: e, dispatch: t }) => D(e, t)
+    };
+  },
+  addProseMirrorPlugins() {
+    return [O(this.options)];
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-z": () => this.editor.commands.undo(),
+      "Shift-Mod-z": () => this.editor.commands.redo(),
+      "Mod-y": () => this.editor.commands.redo(),
+      // Russian keyboard layouts
+      "Mod-я": () => this.editor.commands.undo(),
+      "Shift-Mod-я": () => this.editor.commands.redo()
+    };
+  }
+});
+export {
+  V as Dropcursor,
+  X as Gapcursor,
+  g as PLUGIN_KEY,
+  Z as TrailingNode,
+  J as UndoRedo,
+  G as preparePlaceholderAttribute,
+  I as skipTrailingNodeMeta
+};