@lunejs/admin-ui 0.1.4 → 0.2.0

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

@@ -0,0 +1,66 @@
+import { Mark as d, mergeAttributes as a } from "../../core/dist/index.js";
+var s = d.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", a(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()
+    };
+  }
+}), l = s;
+export {
+  s as Underline,
+  l as default
+};

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

@@ -0,0 +1,481 @@
+import o, { useContext as l, createContext as h, useRef as S, useState as p, useDebugValue as m, useEffect as f, forwardRef as C, useLayoutEffect as y } from "react";
+import w from "react-dom";
+import { s as b } from "../../../../_virtual/index6.js";
+import { jsxs as R, Fragment as v, jsx as a } from "react/jsx-runtime";
+import { Editor as x } from "../../core/dist/index.js";
+import { CommandManager as Z, Extendable as $, Extension as ee, InputRule as te, MappablePosition as ne, Mark as re, Node as ie, NodePos as se, PasteRule as oe, callOrReturn as ae, combineTransactionSteps as de, commands as ue, createAtomBlockMarkdownSpec as ce, createBlockMarkdownSpec as le, createChainableState as he, createDocument as pe, createInlineMarkdownSpec as me, createMappablePosition as fe, createNodeFromContent as be, createStyleTag as ve, defaultBlockAt as Ee, deleteProps as ge, elementFromString as Se, extensions as Ce, findChildrenInRange as ye, findDuplicates as we, findParentNode as Re, findParentNodeClosestToPos as xe, flattenExtensions as Ne, fromString as De, getAttributes as Te, getAttributesFromExtensions as _e, getChangedRanges as Me, getExtensionField as Ie, getHTMLFromFragment as Ae, getMarkAttributes as Pe, getMarkRange as Oe, getMarkType as ke, getMarksBetween as Be, getNodeAtPosition as Fe, getNodeAttributes as Ve, getNodeType as ze, getRenderedAttributes as Ue, getSchemaByResolvedExtensions as je, getSchemaTypeByName as qe, getSchemaTypeNameByName as Le, getSplittedAttributes as We, getText as He, getTextBetween as Ke, getTextContentFromNodes as Ge, getTextSerializersFromSchema as Je, getUpdatedPosition as Qe, injectExtensionAttributesToParseRule as Xe, inputRulesPlugin as Ye, isActive as Ze, isAndroid as $e, isAtEndOfNode as et, isAtStartOfNode as tt, isEmptyObject as nt, isExtensionRulesEnabled as rt, isFunction as it, isList as st, isMacOS as ot, isMarkActive as at, isNodeActive as dt, isNodeEmpty as ut, isNumber as ct, isPlainObject as lt, isRegExp as ht, isTextSelection as pt, isiOS as mt, markInputRule as ft, markPasteRule as bt, markdown as vt, mergeAttributes as Et, mergeDeep as gt, minMax as St, objectIncludes as Ct, parseAttributes as yt, parseIndentedBlocks as wt, pasteRulesPlugin as Rt, removeDuplicates as xt, renderNestedMarkdownContent as Nt, resolveExtensions as Dt, resolveFocusPosition as Tt, selectionToInsertionEnd as _t, serializeAttributes as Mt, sortExtensions as It, splitExtensions as At, textblockTypeInputRule as Pt, updateMarkViewAttributes as Ot, wrappingInputRule as kt } from "../../core/dist/index.js";
+import { deepEqual as N } from "../../../fast-equals/dist/es/index.js";
+import { w as D } from "../../../../_virtual/with-selector.js";
+var T = (...r) => (e) => {
+  r.forEach((t) => {
+    typeof t == "function" ? t(e) : t && (t.current = e);
+  });
+}, _ = ({ contentComponent: r }) => {
+  const e = b.useSyncExternalStore(
+    r.subscribe,
+    r.getSnapshot,
+    r.getServerSnapshot
+  );
+  return /* @__PURE__ */ a(v, { children: Object.values(e) });
+};
+function M() {
+  const r = /* @__PURE__ */ new Set();
+  let e = {};
+  return {
+    /**
+     * Subscribe to the editor instance's changes.
+     */
+    subscribe(t) {
+      return r.add(t), () => {
+        r.delete(t);
+      };
+    },
+    getSnapshot() {
+      return e;
+    },
+    getServerSnapshot() {
+      return e;
+    },
+    /**
+     * Adds a new NodeView Renderer to the editor.
+     */
+    setRenderer(t, n) {
+      e = {
+        ...e,
+        [t]: w.createPortal(n.reactElement, n.element, t)
+      }, r.forEach((i) => i());
+    },
+    /**
+     * Removes a NodeView Renderer from the editor.
+     */
+    removeRenderer(t) {
+      const n = { ...e };
+      delete n[t], e = n, r.forEach((i) => i());
+    }
+  };
+}
+var I = class extends o.Component {
+  constructor(r) {
+    var e;
+    super(r), this.editorContentRef = o.createRef(), this.initialized = !1, this.state = {
+      hasContentComponentInitialized: !!((e = r.editor) != null && e.contentComponent)
+    };
+  }
+  componentDidMount() {
+    this.init();
+  }
+  componentDidUpdate() {
+    this.init();
+  }
+  init() {
+    var r;
+    const e = this.props.editor;
+    if (e && !e.isDestroyed && ((r = e.view.dom) != null && r.parentNode)) {
+      if (e.contentComponent)
+        return;
+      const t = this.editorContentRef.current;
+      t.append(...e.view.dom.parentNode.childNodes), e.setOptions({
+        element: t
+      }), e.contentComponent = M(), this.state.hasContentComponentInitialized || (this.unsubscribeToContentComponent = e.contentComponent.subscribe(() => {
+        this.setState((n) => n.hasContentComponentInitialized ? n : {
+          hasContentComponentInitialized: !0
+        }), this.unsubscribeToContentComponent && this.unsubscribeToContentComponent();
+      })), e.createNodeViews(), this.initialized = !0;
+    }
+  }
+  componentWillUnmount() {
+    var r;
+    const e = this.props.editor;
+    if (e) {
+      this.initialized = !1, e.isDestroyed || e.view.setProps({
+        nodeViews: {}
+      }), this.unsubscribeToContentComponent && this.unsubscribeToContentComponent(), e.contentComponent = null;
+      try {
+        if (!((r = e.view.dom) != null && r.parentNode))
+          return;
+        const t = document.createElement("div");
+        t.append(...e.view.dom.parentNode.childNodes), e.setOptions({
+          element: t
+        });
+      } catch {
+      }
+    }
+  }
+  render() {
+    const { editor: r, innerRef: e, ...t } = this.props;
+    return /* @__PURE__ */ R(v, { children: [
+      /* @__PURE__ */ a("div", { ref: T(e, this.editorContentRef), ...t }),
+      r?.contentComponent && /* @__PURE__ */ a(_, { contentComponent: r.contentComponent })
+    ] });
+  }
+}, A = C(
+  (r, e) => {
+    const t = o.useMemo(() => Math.floor(Math.random() * 4294967295).toString(), [r.editor]);
+    return o.createElement(I, {
+      key: t,
+      innerRef: e,
+      ...r
+    });
+  }
+), G = o.memo(A), P = typeof window < "u" ? y : f, O = class {
+  constructor(r) {
+    this.transactionNumber = 0, this.lastTransactionNumber = 0, this.subscribers = /* @__PURE__ */ new Set(), this.editor = r, this.lastSnapshot = { editor: r, transactionNumber: 0 }, this.getSnapshot = this.getSnapshot.bind(this), this.getServerSnapshot = this.getServerSnapshot.bind(this), this.watch = this.watch.bind(this), this.subscribe = this.subscribe.bind(this);
+  }
+  /**
+   * Get the current editor instance.
+   */
+  getSnapshot() {
+    return this.transactionNumber === this.lastTransactionNumber ? this.lastSnapshot : (this.lastTransactionNumber = this.transactionNumber, this.lastSnapshot = { editor: this.editor, transactionNumber: this.transactionNumber }, this.lastSnapshot);
+  }
+  /**
+   * Always disable the editor on the server-side.
+   */
+  getServerSnapshot() {
+    return { editor: null, transactionNumber: 0 };
+  }
+  /**
+   * Subscribe to the editor instance's changes.
+   */
+  subscribe(r) {
+    return this.subscribers.add(r), () => {
+      this.subscribers.delete(r);
+    };
+  }
+  /**
+   * Watch the editor instance for changes.
+   */
+  watch(r) {
+    if (this.editor = r, this.editor) {
+      const e = () => {
+        this.transactionNumber += 1, this.subscribers.forEach((n) => n());
+      }, t = this.editor;
+      return t.on("transaction", e), () => {
+        t.off("transaction", e);
+      };
+    }
+  }
+};
+function k(r) {
+  var e;
+  const [t] = p(() => new O(r.editor)), n = D.useSyncExternalStoreWithSelector(
+    t.subscribe,
+    t.getSnapshot,
+    t.getServerSnapshot,
+    r.selector,
+    (e = r.equalityFn) != null ? e : N
+  );
+  return P(() => t.watch(r.editor), [r.editor, t]), m(n), n;
+}
+var c = process.env.NODE_ENV !== "production", d = typeof window > "u", B = d || !!(typeof window < "u" && window.next), F = class E {
+  constructor(e) {
+    this.editor = null, this.subscriptions = /* @__PURE__ */ new Set(), this.isComponentMounted = !1, this.previousDeps = null, this.instanceId = "", this.options = e, this.subscriptions = /* @__PURE__ */ new Set(), this.setEditor(this.getInitialEditor()), this.scheduleDestroy(), this.getEditor = this.getEditor.bind(this), this.getServerSnapshot = this.getServerSnapshot.bind(this), this.subscribe = this.subscribe.bind(this), this.refreshEditorInstance = this.refreshEditorInstance.bind(this), this.scheduleDestroy = this.scheduleDestroy.bind(this), this.onRender = this.onRender.bind(this), this.createEditor = this.createEditor.bind(this);
+  }
+  setEditor(e) {
+    this.editor = e, this.instanceId = Math.random().toString(36).slice(2, 9), this.subscriptions.forEach((t) => t());
+  }
+  getInitialEditor() {
+    if (this.options.current.immediatelyRender === void 0) {
+      if (d || B) {
+        if (c)
+          throw new Error(
+            "Tiptap Error: SSR has been detected, please set `immediatelyRender` explicitly to `false` to avoid hydration mismatches."
+          );
+        return null;
+      }
+      return this.createEditor();
+    }
+    if (this.options.current.immediatelyRender && d && c)
+      throw new Error(
+        "Tiptap Error: SSR has been detected, and `immediatelyRender` has been set to `true` this is an unsupported configuration that may result in errors, explicitly set `immediatelyRender` to `false` to avoid hydration mismatches."
+      );
+    return this.options.current.immediatelyRender ? this.createEditor() : null;
+  }
+  /**
+   * Create a new editor instance. And attach event listeners.
+   */
+  createEditor() {
+    const e = {
+      ...this.options.current,
+      // Always call the most recent version of the callback function by default
+      onBeforeCreate: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onBeforeCreate) == null ? void 0 : s.call(i, ...n);
+      },
+      onBlur: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onBlur) == null ? void 0 : s.call(i, ...n);
+      },
+      onCreate: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onCreate) == null ? void 0 : s.call(i, ...n);
+      },
+      onDestroy: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onDestroy) == null ? void 0 : s.call(i, ...n);
+      },
+      onFocus: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onFocus) == null ? void 0 : s.call(i, ...n);
+      },
+      onSelectionUpdate: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onSelectionUpdate) == null ? void 0 : s.call(i, ...n);
+      },
+      onTransaction: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onTransaction) == null ? void 0 : s.call(i, ...n);
+      },
+      onUpdate: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onUpdate) == null ? void 0 : s.call(i, ...n);
+      },
+      onContentError: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onContentError) == null ? void 0 : s.call(i, ...n);
+      },
+      onDrop: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onDrop) == null ? void 0 : s.call(i, ...n);
+      },
+      onPaste: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onPaste) == null ? void 0 : s.call(i, ...n);
+      },
+      onDelete: (...n) => {
+        var i, s;
+        return (s = (i = this.options.current).onDelete) == null ? void 0 : s.call(i, ...n);
+      }
+    };
+    return new x(e);
+  }
+  /**
+   * Get the current editor instance.
+   */
+  getEditor() {
+    return this.editor;
+  }
+  /**
+   * Always disable the editor on the server-side.
+   */
+  getServerSnapshot() {
+    return null;
+  }
+  /**
+   * Subscribe to the editor instance's changes.
+   */
+  subscribe(e) {
+    return this.subscriptions.add(e), () => {
+      this.subscriptions.delete(e);
+    };
+  }
+  static compareOptions(e, t) {
+    return Object.keys(e).every((n) => [
+      "onCreate",
+      "onBeforeCreate",
+      "onDestroy",
+      "onUpdate",
+      "onTransaction",
+      "onFocus",
+      "onBlur",
+      "onSelectionUpdate",
+      "onContentError",
+      "onDrop",
+      "onPaste"
+    ].includes(n) ? !0 : n === "extensions" && e.extensions && t.extensions ? e.extensions.length !== t.extensions.length ? !1 : e.extensions.every((i, s) => {
+      var u;
+      return i === ((u = t.extensions) == null ? void 0 : u[s]);
+    }) : e[n] === t[n]);
+  }
+  /**
+   * On each render, we will create, update, or destroy the editor instance.
+   * @param deps The dependencies to watch for changes
+   * @returns A cleanup function
+   */
+  onRender(e) {
+    return () => (this.isComponentMounted = !0, clearTimeout(this.scheduledDestructionTimeout), this.editor && !this.editor.isDestroyed && e.length === 0 ? E.compareOptions(this.options.current, this.editor.options) || this.editor.setOptions({
+      ...this.options.current,
+      editable: this.editor.isEditable
+    }) : this.refreshEditorInstance(e), () => {
+      this.isComponentMounted = !1, this.scheduleDestroy();
+    });
+  }
+  /**
+   * Recreate the editor instance if the dependencies have changed.
+   */
+  refreshEditorInstance(e) {
+    if (this.editor && !this.editor.isDestroyed) {
+      if (this.previousDeps === null) {
+        this.previousDeps = e;
+        return;
+      }
+      if (this.previousDeps.length === e.length && this.previousDeps.every((n, i) => n === e[i]))
+        return;
+    }
+    this.editor && !this.editor.isDestroyed && this.editor.destroy(), this.setEditor(this.createEditor()), this.previousDeps = e;
+  }
+  /**
+   * Schedule the destruction of the editor instance.
+   * This will only destroy the editor if it was not mounted on the next tick.
+   * This is to avoid destroying the editor instance when it's actually still mounted.
+   */
+  scheduleDestroy() {
+    const e = this.instanceId, t = this.editor;
+    this.scheduledDestructionTimeout = setTimeout(() => {
+      if (this.isComponentMounted && this.instanceId === e) {
+        t && t.setOptions(this.options.current);
+        return;
+      }
+      t && !t.isDestroyed && (t.destroy(), this.instanceId === e && this.setEditor(null));
+    }, 1);
+  }
+};
+function J(r = {}, e = []) {
+  const t = S(r);
+  t.current = r;
+  const [n] = p(() => new F(t)), i = b.useSyncExternalStore(
+    n.subscribe,
+    n.getEditor,
+    n.getServerSnapshot
+  );
+  return m(i), f(n.onRender(e)), k({
+    editor: i,
+    selector: ({ transactionNumber: s }) => r.shouldRerenderOnTransaction === !1 || r.shouldRerenderOnTransaction === void 0 ? null : r.immediatelyRender && s === 0 ? 0 : s + 1
+  }), i;
+}
+var g = h({
+  editor: null
+});
+g.Consumer;
+var Q = () => l(g), V = h({
+  onDragStart: () => {
+  },
+  nodeViewContentChildren: void 0,
+  nodeViewContentRef: () => {
+  }
+}), z = () => l(V);
+o.forwardRef((r, e) => {
+  const { onDragStart: t } = z(), n = r.as || "div";
+  return (
+    // @ts-ignore
+    /* @__PURE__ */ a(
+      n,
+      {
+        ...r,
+        ref: e,
+        "data-node-view-wrapper": "",
+        onDragStart: t,
+        style: {
+          whiteSpace: "normal",
+          ...r.style
+        }
+      }
+    )
+  );
+});
+o.createContext({
+  markViewContentRef: () => {
+  }
+});
+export {
+  Z as CommandManager,
+  x as Editor,
+  G as EditorContent,
+  g as EditorContext,
+  $ as Extendable,
+  ee as Extension,
+  te as InputRule,
+  ne as MappablePosition,
+  re as Mark,
+  ie as Node,
+  se as NodePos,
+  oe as PasteRule,
+  I as PureEditorContent,
+  V as ReactNodeViewContext,
+  ae as callOrReturn,
+  de as combineTransactionSteps,
+  ue as commands,
+  ce as createAtomBlockMarkdownSpec,
+  le as createBlockMarkdownSpec,
+  he as createChainableState,
+  pe as createDocument,
+  me as createInlineMarkdownSpec,
+  fe as createMappablePosition,
+  be as createNodeFromContent,
+  ve as createStyleTag,
+  Ee as defaultBlockAt,
+  ge as deleteProps,
+  Se as elementFromString,
+  Ce as extensions,
+  ye as findChildrenInRange,
+  we as findDuplicates,
+  Re as findParentNode,
+  xe as findParentNodeClosestToPos,
+  Ne as flattenExtensions,
+  De as fromString,
+  Te as getAttributes,
+  _e as getAttributesFromExtensions,
+  Me as getChangedRanges,
+  Ie as getExtensionField,
+  Ae as getHTMLFromFragment,
+  Pe as getMarkAttributes,
+  Oe as getMarkRange,
+  ke as getMarkType,
+  Be as getMarksBetween,
+  Fe as getNodeAtPosition,
+  Ve as getNodeAttributes,
+  ze as getNodeType,
+  Ue as getRenderedAttributes,
+  je as getSchemaByResolvedExtensions,
+  qe as getSchemaTypeByName,
+  Le as getSchemaTypeNameByName,
+  We as getSplittedAttributes,
+  He as getText,
+  Ke as getTextBetween,
+  Ge as getTextContentFromNodes,
+  Je as getTextSerializersFromSchema,
+  Qe as getUpdatedPosition,
+  Xe as injectExtensionAttributesToParseRule,
+  Ye as inputRulesPlugin,
+  Ze as isActive,
+  $e as isAndroid,
+  et as isAtEndOfNode,
+  tt as isAtStartOfNode,
+  nt as isEmptyObject,
+  rt as isExtensionRulesEnabled,
+  it as isFunction,
+  st as isList,
+  ot as isMacOS,
+  at as isMarkActive,
+  dt as isNodeActive,
+  ut as isNodeEmpty,
+  ct as isNumber,
+  lt as isPlainObject,
+  ht as isRegExp,
+  pt as isTextSelection,
+  mt as isiOS,
+  ft as markInputRule,
+  bt as markPasteRule,
+  vt as markdown,
+  Et as mergeAttributes,
+  gt as mergeDeep,
+  St as minMax,
+  Ct as objectIncludes,
+  yt as parseAttributes,
+  wt as parseIndentedBlocks,
+  Rt as pasteRulesPlugin,
+  xt as removeDuplicates,
+  Nt as renderNestedMarkdownContent,
+  Dt as resolveExtensions,
+  Tt as resolveFocusPosition,
+  _t as selectionToInsertionEnd,
+  Mt as serializeAttributes,
+  It as sortExtensions,
+  At as splitExtensions,
+  Pt as textblockTypeInputRule,
+  Ot as updateMarkViewAttributes,
+  Q as useCurrentEditor,
+  J as useEditor,
+  k as useEditorState,
+  z as useReactNodeView,
+  kt as wrappingInputRule
+};

package/dist/node_modules/eventemitter3/index.js

@@ -1,4 +1,4 @@
-import e from "../../_virtual/index8.js";
+import e from "../../_virtual/index10.js";
 export {
   e as EventEmitter,
   e as default

package/dist/node_modules/eventemitter3/index2.js

@@ -1,4 +1,4 @@
-import { __module as x } from "../../_virtual/index10.js";
+import { __module as x } from "../../_virtual/index11.js";
 var w;
 function O() {
   return w ? x.exports : (w = 1, (function(d) {