@cgboiler/biz-basic 1.0.67 → 1.0.68

package/lib/rich-text-editor/lib/utils.d.ts

@@ -0,0 +1,123 @@
+import type { Node as TiptapNode } from '@tiptap/pm/model';
+import type { Editor } from '@tiptap/core';
+import { type ClassValue } from 'clsx';
+export declare const MAX_FILE_SIZE: number;
+export declare const MAC_SYMBOLS: Record<string, string>;
+export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Determines if the current platform is macOS
+ * @returns boolean indicating if the current platform is Mac
+ */
+export declare function isMac(): boolean;
+/**
+ * Formats a shortcut key based on the platform (Mac or non-Mac)
+ * @param key - The key to format (e.g., "ctrl", "alt", "shift")
+ * @param isMac - Boolean indicating if the platform is Mac
+ * @param capitalize - Whether to capitalize the key (default: true)
+ * @returns Formatted shortcut key symbol
+ */
+export declare const formatShortcutKey: (key: string, isMac: boolean, capitalize?: boolean) => string;
+/**
+ * Parses a shortcut key string into an array of formatted key symbols
+ * @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+ * @param delimiter - The delimiter used to split the keys (default: "-")
+ * @param capitalize - Whether to capitalize the keys (default: true)
+ * @returns Array of formatted shortcut key symbols
+ */
+export declare const parseShortcutKeys: (props: {
+    shortcutKeys: string | undefined;
+    delimiter?: string;
+    capitalize?: boolean;
+}) => string[];
+/**
+ * Checks if a mark exists in the editor schema
+ * @param markName - The name of the mark to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the mark exists in the schema
+ */
+export declare const isMarkInSchema: (markName: string, editor: Editor | null) => boolean;
+/**
+ * Checks if a node exists in the editor schema
+ * @param nodeName - The name of the node to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the node exists in the schema
+ */
+export declare const isNodeInSchema: (nodeName: string, editor: Editor | null) => boolean;
+/**
+ * Moves the focus to the next node in the editor
+ * @param editor - The editor instance
+ * @returns boolean indicating if the focus was moved
+ */
+export declare function focusNextNode(editor: Editor): boolean;
+/**
+ * Checks if a value is a valid number (not null, undefined, or NaN)
+ * @param value - The value to check
+ * @returns boolean indicating if the value is a valid number
+ */
+export declare function isValidPosition(pos: number | null | undefined): pos is number;
+/**
+ * Checks if one or more extensions are registered in the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionNames - A single extension name or an array of names to check
+ * @returns True if at least one of the extensions is available, false otherwise
+ */
+export declare function isExtensionAvailable(editor: Editor | null, extensionNames: string | string[]): boolean;
+/**
+ * Finds a node at the specified position with error handling
+ * @param editor The Tiptap editor instance
+ * @param position The position in the document to find the node
+ * @returns The node at the specified position, or null if not found
+ */
+export declare function findNodeAtPosition(editor: Editor, position: number): TiptapNode | null;
+/**
+ * Finds the position and instance of a node in the document
+ * @param props Object containing editor, node (optional), and nodePos (optional)
+ * @param props.editor The Tiptap editor instance
+ * @param props.node The node to find (optional if nodePos is provided)
+ * @param props.nodePos The position of the node to find (optional if node is provided)
+ * @returns An object with the position and node, or null if not found
+ */
+export declare function findNodePosition(props: {
+    editor: Editor | null;
+    node?: TiptapNode | null;
+    nodePos?: number | null;
+}): {
+    pos: number;
+    node: TiptapNode;
+} | null;
+/**
+ * Checks if the current selection in the editor is a node selection of specified types
+ * @param editor The Tiptap editor instance
+ * @param types An array of node type names to check against
+ * @returns boolean indicating if the selected node matches any of the specified types
+ */
+export declare function isNodeTypeSelected(editor: Editor | null, types?: string[]): boolean;
+/**
+ * Handles image upload with progress tracking and abort capability
+ * @param file The file to upload
+ * @param onProgress Optional callback for tracking upload progress
+ * @param abortSignal Optional AbortSignal for cancelling the upload
+ * @returns Promise resolving to the URL of the uploaded image
+ */
+export declare const handleImageUpload: (file: File, onProgress?: (event: {
+    progress: number;
+}) => void, abortSignal?: AbortSignal) => Promise<string>;
+type ProtocolOptions = {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+};
+type ProtocolConfig = Array<ProtocolOptions | string>;
+export declare function isAllowedUri(uri: string | undefined, protocols?: ProtocolConfig): true | RegExpMatchArray | null;
+export declare function sanitizeUrl(inputUrl: string, baseUrl: string, protocols?: ProtocolConfig): string;
+export {};

package/lib/rich-text-editor/lib/utils.js

@@ -0,0 +1,263 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var stdin_exports = {};
+__export(stdin_exports, {
+  MAC_SYMBOLS: () => MAC_SYMBOLS,
+  MAX_FILE_SIZE: () => MAX_FILE_SIZE,
+  cn: () => cn,
+  findNodeAtPosition: () => findNodeAtPosition,
+  findNodePosition: () => findNodePosition,
+  focusNextNode: () => focusNextNode,
+  formatShortcutKey: () => formatShortcutKey,
+  handleImageUpload: () => handleImageUpload,
+  isAllowedUri: () => isAllowedUri,
+  isExtensionAvailable: () => isExtensionAvailable,
+  isMac: () => isMac,
+  isMarkInSchema: () => isMarkInSchema,
+  isNodeInSchema: () => isNodeInSchema,
+  isNodeTypeSelected: () => isNodeTypeSelected,
+  isValidPosition: () => isValidPosition,
+  parseShortcutKeys: () => parseShortcutKeys,
+  sanitizeUrl: () => sanitizeUrl
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_state = require("@tiptap/pm/state");
+var import_clsx = require("clsx");
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+const MAC_SYMBOLS = {
+  mod: "\u2318",
+  command: "\u2318",
+  meta: "\u2318",
+  ctrl: "\u2303",
+  control: "\u2303",
+  alt: "\u2325",
+  option: "\u2325",
+  shift: "\u21E7",
+  backspace: "Del",
+  delete: "\u2326",
+  enter: "\u23CE",
+  escape: "\u238B",
+  capslock: "\u21EA"
+};
+function cn(...inputs) {
+  return (0, import_clsx.clsx)(inputs);
+}
+function isMac() {
+  return typeof navigator !== "undefined" && navigator.platform.toLowerCase().includes("mac");
+}
+const formatShortcutKey = (key, isMac2, capitalize = true) => {
+  if (isMac2) {
+    const lowerKey = key.toLowerCase();
+    return MAC_SYMBOLS[lowerKey] || (capitalize ? key.toUpperCase() : key);
+  }
+  return capitalize ? key.charAt(0).toUpperCase() + key.slice(1) : key;
+};
+const parseShortcutKeys = (props) => {
+  const { shortcutKeys, delimiter = "+", capitalize = true } = props;
+  if (!shortcutKeys)
+    return [];
+  return shortcutKeys.split(delimiter).map((key) => key.trim()).map((key) => formatShortcutKey(key, isMac(), capitalize));
+};
+const isMarkInSchema = (markName, editor) => {
+  if (!(editor == null ? void 0 : editor.schema))
+    return false;
+  return editor.schema.spec.marks.get(markName) !== void 0;
+};
+const isNodeInSchema = (nodeName, editor) => {
+  if (!(editor == null ? void 0 : editor.schema))
+    return false;
+  return editor.schema.spec.nodes.get(nodeName) !== void 0;
+};
+function focusNextNode(editor) {
+  const { state, view } = editor;
+  const { doc, selection } = state;
+  const nextSel = import_state.Selection.findFrom(selection.$to, 1, true);
+  if (nextSel) {
+    view.dispatch(state.tr.setSelection(nextSel).scrollIntoView());
+    return true;
+  }
+  const paragraphType = state.schema.nodes.paragraph;
+  if (!paragraphType) {
+    console.warn("No paragraph node type found in schema.");
+    return false;
+  }
+  const end = doc.content.size;
+  const para = paragraphType.create();
+  let tr = state.tr.insert(end, para);
+  const $inside = tr.doc.resolve(end + 1);
+  tr = tr.setSelection(import_state.TextSelection.near($inside)).scrollIntoView();
+  view.dispatch(tr);
+  return true;
+}
+function isValidPosition(pos) {
+  return typeof pos === "number" && pos >= 0;
+}
+function isExtensionAvailable(editor, extensionNames) {
+  if (!editor)
+    return false;
+  const names = Array.isArray(extensionNames) ? extensionNames : [extensionNames];
+  const found = names.some(
+    (name) => editor.extensionManager.extensions.some((ext) => ext.name === name)
+  );
+  if (!found) {
+    console.warn(
+      `None of the extensions [${names.join(
+        ", "
+      )}] were found in the editor schema. Ensure they are included in the editor configuration.`
+    );
+  }
+  return found;
+}
+function findNodeAtPosition(editor, position) {
+  try {
+    const node = editor.state.doc.nodeAt(position);
+    if (!node) {
+      console.warn(`No node found at position ${position}`);
+      return null;
+    }
+    return node;
+  } catch (error) {
+    console.error(`Error getting node at position ${position}:`, error);
+    return null;
+  }
+}
+function findNodePosition(props) {
+  var _a;
+  const { editor, node, nodePos } = props;
+  if (!editor || !((_a = editor.state) == null ? void 0 : _a.doc))
+    return null;
+  const hasValidNode = node !== void 0 && node !== null;
+  const hasValidPos = isValidPosition(nodePos);
+  if (!hasValidNode && !hasValidPos) {
+    return null;
+  }
+  if (hasValidNode) {
+    let foundPos = -1;
+    let foundNode = null;
+    editor.state.doc.descendants((currentNode, pos) => {
+      if (currentNode === node) {
+        foundPos = pos;
+        foundNode = currentNode;
+        return false;
+      }
+      return true;
+    });
+    if (foundPos !== -1 && foundNode !== null) {
+      return { pos: foundPos, node: foundNode };
+    }
+  }
+  if (hasValidPos) {
+    const nodeAtPos = findNodeAtPosition(editor, nodePos);
+    if (nodeAtPos) {
+      return { pos: nodePos, node: nodeAtPos };
+    }
+  }
+  return null;
+}
+function isNodeTypeSelected(editor, types = []) {
+  if (!editor || !editor.state.selection)
+    return false;
+  const { state } = editor;
+  const { selection } = state;
+  if (selection.empty)
+    return false;
+  if (selection instanceof import_state.NodeSelection) {
+    const node = selection.node;
+    return node ? types.includes(node.type.name) : false;
+  }
+  return false;
+}
+const handleImageUpload = (file, onProgress, abortSignal) => __async(void 0, null, function* () {
+  if (!file) {
+    throw new Error("No file provided");
+  }
+  if (file.size > MAX_FILE_SIZE) {
+    throw new Error(`File size exceeds maximum allowed (${MAX_FILE_SIZE / (1024 * 1024)}MB)`);
+  }
+  for (let progress = 0; progress <= 100; progress += 10) {
+    if (abortSignal == null ? void 0 : abortSignal.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    yield new Promise((resolve) => setTimeout(resolve, 500));
+    onProgress == null ? void 0 : onProgress({ progress });
+  }
+  return "/images/tiptap-ui-placeholder-image.jpg";
+});
+const ATTR_WHITESPACE = (
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+);
+function isAllowedUri(uri, protocols) {
+  const allowedProtocols = [
+    "http",
+    "https",
+    "ftp",
+    "ftps",
+    "mailto",
+    "tel",
+    "callto",
+    "sms",
+    "cid",
+    "xmpp"
+  ];
+  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
+      `^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
+      "i"
+    )
+  );
+}
+function sanitizeUrl(inputUrl, baseUrl, protocols) {
+  try {
+    const url = new URL(inputUrl, baseUrl);
+    if (isAllowedUri(url.href, protocols)) {
+      return url.href;
+    }
+  } catch (e) {
+  }
+  return "#";
+}

package/lib/rich-text-editor/menu-system/components/_atomic.css

@@ -39,6 +39,8 @@
 
 
 
+/* layer: default */
+.cgx-atm .table{display:table;}
 
 
 

package/lib/rich-text-editor/menu-system/components/table-dropdown-menu.d.ts

@@ -0,0 +1,25 @@
+import { type PropType } from 'vue';
+import 'element-plus/es/components/dropdown/style/css';
+import 'element-plus/es/components/dropdown-menu/style/css';
+import 'element-plus/es/components/dropdown-item/style/css';
+export declare const TableDropdownMenu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    editor: {
+        type: PropType<any>;
+        required: true;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    editor: {
+        type: PropType<any>;
+        required: true;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    className: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/rich-text-editor/menu-system/components/table-dropdown-menu.js

@@ -0,0 +1,186 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  TableDropdownMenu: () => TableDropdownMenu
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_atomic = require("./_atomic.css");
+var import_vue2 = require("vue");
+var import_button = require("../primitives/button");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+var import_element_plus = require("element-plus");
+var import_icons = require("../icons");
+var import_css = require("element-plus/es/components/dropdown/style/css");
+var import_css2 = require("element-plus/es/components/dropdown-menu/style/css");
+var import_css3 = require("element-plus/es/components/dropdown-item/style/css");
+const TableDropdownMenu = (0, import_vue2.defineComponent)({
+  name: "TableDropdownMenu",
+  props: {
+    editor: {
+      type: Object,
+      required: true
+    },
+    className: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props, {
+    attrs
+  }) {
+    const handleCommand = (command) => {
+      const editor = props.editor && "value" in props.editor ? props.editor.value : props.editor;
+      if (!editor)
+        return;
+      switch (command) {
+        case "insertTable":
+          editor.commands.insertTable({
+            rows: 3,
+            cols: 3,
+            withHeaderRow: true
+          });
+          break;
+        case "addColumnBefore":
+          editor.commands.addColumnBefore();
+          break;
+        case "addColumnAfter":
+          editor.commands.addColumnAfter();
+          break;
+        case "deleteColumn":
+          editor.commands.deleteColumn();
+          break;
+        case "addRowBefore":
+          editor.commands.addRowBefore();
+          break;
+        case "addRowAfter":
+          editor.commands.addRowAfter();
+          break;
+        case "deleteRow":
+          editor.commands.deleteRow();
+          break;
+        case "deleteTable":
+          editor.commands.deleteTable();
+          break;
+        case "mergeCells":
+          editor.commands.mergeCells();
+          break;
+        case "splitCell":
+          editor.commands.splitCell();
+          break;
+        case "toggleHeaderRow":
+          editor.commands.toggleHeaderRow();
+          break;
+        case "toggleHeaderColumn":
+          editor.commands.toggleHeaderColumn();
+          break;
+        case "toggleHeaderCell":
+          editor.commands.toggleHeaderCell();
+          break;
+        default:
+          break;
+      }
+    };
+    const isInTable = () => {
+      const editor = props.editor && "value" in props.editor ? props.editor.value : props.editor;
+      return editor == null ? void 0 : editor.isActive("table");
+    };
+    return () => {
+      const trigger = (0, import_vue.createVNode)(import_button.Button, (0, import_vue.mergeProps)({
+        "type": "button",
+        "data-style": "ghost",
+        "data-active-state": isInTable() ? "on" : "off",
+        "role": "button",
+        "tooltip": "\u8868\u683C\u64CD\u4F5C",
+        "class": (0, import_tiptap_utils.cn)(props.className, "tiptap-table-dropdown-trigger")
+      }, attrs), {
+        default: () => [(0, import_vue.createVNode)(import_icons.TableIcon, {
+          "class": "tiptap-button-icon"
+        }, null), (0, import_vue.createVNode)(import_icons.ChevronDownIcon, {
+          "class": "tiptap-button-icon-chevron"
+        }, null)]
+      });
+      return (0, import_vue.createVNode)(import_element_plus.ElDropdown, {
+        "trigger": "click",
+        "onCommand": handleCommand,
+        "popper-class": "tiptap-dropdown-menu"
+      }, {
+        default: () => trigger,
+        dropdown: () => (0, import_vue.createVNode)(import_element_plus.ElDropdownMenu, null, {
+          default: () => [!isInTable() ? (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "insertTable"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u63D2\u5165\u8868\u683C")]
+          }) : (0, import_vue.createVNode)(import_vue.Fragment, null, [(0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "addColumnBefore"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5728\u524D\u65B9\u63D2\u5165\u5217")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "addColumnAfter"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5728\u540E\u65B9\u63D2\u5165\u5217")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "deleteColumn"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5220\u9664\u5F53\u524D\u5217")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "divided": true,
+            "command": "addRowBefore"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5728\u4E0A\u65B9\u63D2\u5165\u884C")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "addRowAfter"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5728\u4E0B\u65B9\u63D2\u5165\u884C")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "deleteRow"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5220\u9664\u5F53\u524D\u884C")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "divided": true,
+            "command": "mergeCells"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5408\u5E76\u5355\u5143\u683C")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "splitCell"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u62C6\u5206\u5355\u5143\u683C")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "divided": true,
+            "command": "toggleHeaderRow"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5207\u6362\u8868\u5934\u884C")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "command": "toggleHeaderColumn"
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5207\u6362\u8868\u5934\u5217")]
+          }), (0, import_vue.createVNode)(import_element_plus.ElDropdownItem, {
+            "divided": true,
+            "command": "deleteTable",
+            "style": {
+              color: "var(--red)"
+            }
+          }, {
+            default: () => [(0, import_vue.createTextVNode)("\u5220\u9664\u8868\u683C")]
+          })])]
+        })
+      });
+    };
+  }
+});

package/lib/rich-text-editor/menu-system/icons/index.d.ts

@@ -544,3 +544,16 @@ export declare const DivideIcon: import("vue").DefineComponent<import("vue").Ext
 }>> & Readonly<{}>, {
     className: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TableIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    className: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/rich-text-editor/menu-system/icons/index.js

@@ -56,6 +56,7 @@ __export(stdin_exports, {
   StrikeIcon: () => StrikeIcon,
   SubscriptIcon: () => SubscriptIcon,
   SuperscriptIcon: () => SuperscriptIcon,
+  TableIcon: () => TableIcon,
   TrashIcon: () => TrashIcon,
   UnderlineIcon: () => UnderlineIcon,
   Undo2Icon: () => Undo2Icon
@@ -504,3 +505,28 @@ const DivideIcon = createIcon("DivideIcon", (0, import_vue.createVNode)("path",
   "stroke-width": "2",
   "stroke-linecap": "round"
 }, null));
+const TableIcon = createIcon("TableIcon", (0, import_vue.createVNode)(import_vue.Fragment, null, [(0, import_vue.createVNode)("rect", {
+  "x": "3",
+  "y": "3",
+  "width": "18",
+  "height": "18",
+  "rx": "2",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), (0, import_vue.createVNode)("path", {
+  "d": "M3 9H21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), (0, import_vue.createVNode)("path", {
+  "d": "M3 15H21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), (0, import_vue.createVNode)("path", {
+  "d": "M9 3V21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), (0, import_vue.createVNode)("path", {
+  "d": "M15 3V21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null)]));