@ablogcms/block-editor 3.2.28-beta.0

package/dist/chunk-TKSGCO5Z.mjs

@@ -0,0 +1,2813 @@
+import {
+  Icon
+} from "./chunk-57Q3DEDF.mjs";
+
+// src/lib/utils/index.ts
+import classnames from "classnames";
+
+// src/extensions/index.ts
+import { StarterKit } from "@tiptap/starter-kit";
+import { Highlight } from "@tiptap/extension-highlight";
+import { Underline } from "@tiptap/extension-underline";
+import { TextAlign } from "@tiptap/extension-text-align";
+import { TextStyle } from "@tiptap/extension-text-style";
+import { Typography } from "@tiptap/extension-typography";
+import { Subscript } from "@tiptap/extension-subscript";
+import { Superscript } from "@tiptap/extension-superscript";
+import { Paragraph } from "@tiptap/extension-paragraph";
+import { CodeBlock } from "@tiptap/extension-code-block";
+import { BulletList, OrderedList } from "@tiptap/extension-list";
+import { Placeholder, Focus, Dropcursor } from "@tiptap/extensions";
+
+// src/extensions/Selection/Selection.ts
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var Selection = Extension.create({
+  name: "selection",
+  addProseMirrorPlugins() {
+    const { editor } = this;
+    return [
+      new Plugin({
+        key: new PluginKey("selection"),
+        props: {
+          decorations(state) {
+            if (state.selection.empty) {
+              return null;
+            }
+            if (editor.isFocused === true) {
+              return null;
+            }
+            return DecorationSet.create(state.doc, [
+              Decoration.inline(state.selection.from, state.selection.to, {
+                class: "selection"
+              })
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/Table/Table.ts
+import { Table as TiptapTable } from "@tiptap/extension-table";
+import { mergeAttributes } from "@tiptap/core";
+var Table = TiptapTable.extend({
+  addAttributes() {
+    return {
+      scrollable: {
+        default: true,
+        parseHTML: (element) => {
+          return !!element.getAttribute("data-scrollable");
+        },
+        renderHTML: (attributes) => {
+          return {
+            "data-scrollable": attributes.scrollable ? true : null
+          };
+        }
+      }
+    };
+  },
+  renderHTML({ HTMLAttributes }) {
+    const scrollable = HTMLAttributes["data-scrollable"];
+    const scrollableWrapperClass = scrollable ? ACMS.Config.blockEditorConfig.tableScrollableWrapperClass : "";
+    const scrollableTableClass = ACMS.Config.blockEditorConfig.tableScrollableClass || "";
+    const tableAttrs = mergeAttributes(this.options.HTMLAttributes, HTMLAttributes);
+    const originalClass = tableAttrs.class || "";
+    const classList = originalClass.split(/\s+/).filter((cls) => cls && cls !== scrollableTableClass);
+    if (scrollable) {
+      classList.push(scrollableTableClass);
+    }
+    tableAttrs.class = classList.join(" ");
+    return ["div", { class: `tableWrapper ${scrollableWrapperClass}`.trim() }, ["table", tableAttrs, ["tbody", 0]]];
+  },
+  addCommands() {
+    return {
+      ...this.parent?.(),
+      toggleTableScrollable: () => ({ commands, editor }) => {
+        const { state } = editor;
+        const { from, to } = state.selection;
+        let found = false;
+        state.doc.nodesBetween(from, to, (node) => {
+          if (node.type.name === "table") {
+            found = true;
+            const { scrollable } = node.attrs;
+            commands.updateAttributes("table", { scrollable: !scrollable });
+            return false;
+          }
+        });
+        return found;
+      }
+    };
+  }
+}).configure({
+  resizable: false
+});
+
+// src/extensions/Table/Cell.ts
+import { mergeAttributes as mergeAttributes2, Node } from "@tiptap/core";
+import { Plugin as Plugin2 } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+
+// src/extensions/Table/utils.ts
+import { findParentNode } from "@tiptap/core";
+import { CellSelection, TableMap } from "@tiptap/pm/tables";
+var isRectSelected = (rect) => (selection) => {
+  const map = TableMap.get(selection.$anchorCell.node(-1));
+  const start = selection.$anchorCell.start(-1);
+  const cells = map.cellsInRect(rect);
+  const selectedCells = map.cellsInRect(
+    map.rectBetween(selection.$anchorCell.pos - start, selection.$headCell.pos - start)
+  );
+  for (let i = 0, count = cells.length; i < count; i += 1) {
+    if (selectedCells.indexOf(cells[i]) === -1) {
+      return false;
+    }
+  }
+  return true;
+};
+var findTable = (selection) => findParentNode((node) => node.type.spec.tableRole && node.type.spec.tableRole === "table")(selection);
+var isCellSelection = (selection) => selection instanceof CellSelection;
+var isColumnSelected = (columnIndex) => (selection) => {
+  if (isCellSelection(selection)) {
+    const map = TableMap.get(selection.$anchorCell.node(-1));
+    return isRectSelected({
+      left: columnIndex,
+      right: columnIndex + 1,
+      top: 0,
+      bottom: map.height
+    })(selection);
+  }
+  return false;
+};
+var isRowSelected = (rowIndex) => (selection) => {
+  if (isCellSelection(selection)) {
+    const map = TableMap.get(selection.$anchorCell.node(-1));
+    return isRectSelected({
+      left: 0,
+      right: map.width,
+      top: rowIndex,
+      bottom: rowIndex + 1
+    })(selection);
+  }
+  return false;
+};
+var getCellsInColumn = (columnIndex) => (selection) => {
+  const table = findTable(selection);
+  if (table) {
+    const map = TableMap.get(table.node);
+    const indexes = Array.isArray(columnIndex) ? columnIndex : Array.from([columnIndex]);
+    return indexes.reduce(
+      (acc, index) => {
+        if (index >= 0 && index <= map.width - 1) {
+          const cells = map.cellsInRect({
+            left: index,
+            right: index + 1,
+            top: 0,
+            bottom: map.height
+          });
+          return acc.concat(
+            cells.map((nodePos) => {
+              const node = table.node.nodeAt(nodePos);
+              const pos = nodePos + table.start;
+              return { pos, start: pos + 1, node };
+            })
+          );
+        }
+        return acc;
+      },
+      []
+    );
+  }
+  return null;
+};
+var getCellsInRow = (rowIndex) => (selection) => {
+  const table = findTable(selection);
+  if (table) {
+    const map = TableMap.get(table.node);
+    const indexes = Array.isArray(rowIndex) ? rowIndex : Array.from([rowIndex]);
+    return indexes.reduce(
+      (acc, index) => {
+        if (index >= 0 && index <= map.height - 1) {
+          const cells = map.cellsInRect({
+            left: 0,
+            right: map.width,
+            top: index,
+            bottom: index + 1
+          });
+          return acc.concat(
+            cells.map((nodePos) => {
+              const node = table.node.nodeAt(nodePos);
+              const pos = nodePos + table.start;
+              return { pos, start: pos + 1, node };
+            })
+          );
+        }
+        return acc;
+      },
+      []
+    );
+  }
+  return null;
+};
+var select = (type) => (index) => (tr) => {
+  const table = findTable(tr.selection);
+  const isRowSelection = type === "row";
+  if (table) {
+    const map = TableMap.get(table.node);
+    if (index >= 0 && index < (isRowSelection ? map.height : map.width)) {
+      const left = isRowSelection ? 0 : index;
+      const top = isRowSelection ? index : 0;
+      const right = isRowSelection ? map.width : index + 1;
+      const bottom = isRowSelection ? index + 1 : map.height;
+      const cellsInFirstRow = map.cellsInRect({
+        left,
+        top,
+        right: isRowSelection ? right : left + 1,
+        bottom: isRowSelection ? top + 1 : bottom
+      });
+      const cellsInLastRow = bottom - top === 1 ? cellsInFirstRow : map.cellsInRect({
+        left: isRowSelection ? left : right - 1,
+        top: isRowSelection ? bottom - 1 : top,
+        right,
+        bottom
+      });
+      const head = table.start + cellsInFirstRow[0];
+      const anchor = table.start + cellsInLastRow[cellsInLastRow.length - 1];
+      const $head = tr.doc.resolve(head);
+      const $anchor = tr.doc.resolve(anchor);
+      return tr.setSelection(new CellSelection($anchor, $head));
+    }
+  }
+  return tr;
+};
+var selectColumn = select("column");
+var selectRow = select("row");
+
+// src/extensions/Table/Cell.ts
+var TableCell = Node.create({
+  name: "tableCell",
+  content: "block+",
+  // TODO: Do not allow table in table
+  tableRole: "cell",
+  isolating: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [{ tag: "td" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["td", mergeAttributes2(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1,
+        parseHTML: (element) => {
+          const colspan = element.getAttribute("colspan");
+          const value = colspan ? parseInt(colspan, 10) : 1;
+          return value;
+        }
+      },
+      rowspan: {
+        default: 1,
+        parseHTML: (element) => {
+          const rowspan = element.getAttribute("rowspan");
+          const value = rowspan ? parseInt(rowspan, 10) : 1;
+          return value;
+        }
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (element) => {
+          const colwidth = element.getAttribute("colwidth");
+          const value = colwidth ? [parseInt(colwidth, 10)] : null;
+          return value;
+        }
+      },
+      backgroundColor: {
+        default: null,
+        parseHTML: (element) => {
+          const style = element.getAttribute("style");
+          if (!style) return null;
+          const match = style.match(/background-color:\s*([^;]+)/i);
+          return match ? match[1] : null;
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.backgroundColor) return {};
+          return {
+            style: `background-color: ${attributes.backgroundColor}`
+          };
+        }
+      }
+    };
+  },
+  addCommands() {
+    return {
+      setCellBackgroundColor: (color) => ({ commands }) => {
+        return commands.updateAttributes("tableCell", {
+          backgroundColor: color
+        });
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const { isEditable } = this.editor;
+    return [
+      new Plugin2({
+        props: {
+          decorations: (state) => {
+            if (!isEditable) {
+              return DecorationSet2.empty;
+            }
+            const { doc, selection } = state;
+            const decorations = [];
+            const cells = getCellsInColumn(0)(selection);
+            if (cells) {
+              cells.forEach(({ pos }, index) => {
+                decorations.push(
+                  Decoration2.widget(pos + 1, () => {
+                    const rowSelected = isRowSelected(index)(selection);
+                    let className = "grip-row";
+                    if (rowSelected) {
+                      className += " selected";
+                    }
+                    if (index === 0) {
+                      className += " first";
+                    }
+                    if (index === cells.length - 1) {
+                      className += " last";
+                    }
+                    const grip = document.createElement("button");
+                    const icon = document.createElement("span");
+                    icon.className = "material-symbols-outlined acms-admin-block-editor-icon grip-icon";
+                    icon.textContent = "more_vert";
+                    icon.setAttribute("aria-hidden", "true");
+                    grip.appendChild(icon);
+                    grip.className = className;
+                    grip.type = "button";
+                    grip.addEventListener("mousedown", (event) => {
+                      event.preventDefault();
+                      event.stopImmediatePropagation();
+                      this.editor.view.dispatch(selectRow(index)(this.editor.state.tr));
+                    });
+                    return grip;
+                  })
+                );
+              });
+            }
+            return DecorationSet2.create(doc, decorations);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/Table/Row.ts
+import { TableRow as TiptapTableRow } from "@tiptap/extension-table";
+var TableRow = TiptapTableRow.extend({
+  allowGapCursor: false,
+  content: "(tableCell | tableHeader)*"
+});
+
+// src/extensions/Table/Header.ts
+import { TableHeader as TiptapTableHeader } from "@tiptap/extension-table";
+import { Plugin as Plugin3 } from "@tiptap/pm/state";
+import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "@tiptap/pm/view";
+var TableHeader = TiptapTableHeader.extend({
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (element) => {
+          const colwidth = element.getAttribute("colwidth");
+          const value = colwidth ? colwidth.split(",").map((item) => parseInt(item, 10)) : null;
+          return value;
+        }
+      },
+      backgroundColor: {
+        default: null,
+        parseHTML: (element) => {
+          const style = element.getAttribute("style");
+          if (!style) return null;
+          const match = style.match(/background-color:\s*([^;]+)/i);
+          return match ? match[1] : null;
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.backgroundColor) return {};
+          return {
+            style: `background-color: ${attributes.backgroundColor}`
+          };
+        }
+      }
+    };
+  },
+  addCommands() {
+    return {
+      setHeaderBackgroundColor: (color) => ({ commands }) => {
+        return commands.updateAttributes("tableHeader", {
+          backgroundColor: color
+        });
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const { isEditable } = this.editor;
+    return [
+      new Plugin3({
+        props: {
+          decorations: (state) => {
+            if (!isEditable) {
+              return DecorationSet3.empty;
+            }
+            const { doc, selection } = state;
+            const decorations = [];
+            const cells = getCellsInRow(0)(selection);
+            if (cells) {
+              cells.forEach(({ pos }, index) => {
+                decorations.push(
+                  Decoration3.widget(pos + 1, () => {
+                    const colSelected = isColumnSelected(index)(selection);
+                    let className = "grip-column";
+                    if (colSelected) {
+                      className += " selected";
+                    }
+                    if (index === 0) {
+                      className += " first";
+                    }
+                    if (index === cells.length - 1) {
+                      className += " last";
+                    }
+                    const grip = document.createElement("button");
+                    const icon = document.createElement("span");
+                    icon.className = "material-symbols-outlined acms-admin-block-editor-icon grip-icon";
+                    icon.textContent = "more_horiz";
+                    icon.setAttribute("aria-hidden", "true");
+                    grip.appendChild(icon);
+                    grip.className = className;
+                    grip.type = "button";
+                    grip.addEventListener("mousedown", (event) => {
+                      event.preventDefault();
+                      event.stopImmediatePropagation();
+                      this.editor.view.dispatch(selectColumn(index)(this.editor.state.tr));
+                    });
+                    return grip;
+                  })
+                );
+              });
+            }
+            return DecorationSet3.create(doc, decorations);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/HorizontalRule/HorizontalRule.ts
+import { mergeAttributes as mergeAttributes3 } from "@tiptap/core";
+import { HorizontalRule as TiptapHorizontalRule } from "@tiptap/extension-horizontal-rule";
+var HorizontalRule = TiptapHorizontalRule.extend({
+  renderHTML({ HTMLAttributes }) {
+    const attrs = mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes);
+    return ["div", { "data-type": this.name }, ["hr", attrs]];
+  }
+});
+
+// src/extensions/Heading/Heading.ts
+import { Heading as TiptapHeading } from "@tiptap/extension-heading";
+var Heading = TiptapHeading.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.()
+    };
+  }
+});
+
+// src/extensions/Document/Document.ts
+import { Document as TiptapDocument } from "@tiptap/extension-document";
+var Document = TiptapDocument.extend({
+  content: "(block|columns)+"
+});
+
+// src/extensions/TrailingNode/trailing-node.ts
+import { Extension as Extension2 } from "@tiptap/core";
+import { Plugin as Plugin4, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+function nodeEqualsType({ types, node }) {
+  return Array.isArray(types) && types.includes(node.type) || node.type === types;
+}
+var TrailingNode = Extension2.create({
+  name: "trailingNode",
+  addOptions() {
+    return {
+      node: "paragraph",
+      notAfter: ["paragraph"]
+    };
+  },
+  addProseMirrorPlugins() {
+    const plugin = new PluginKey2(this.name);
+    const disabledNodes = Object.entries(this.editor.schema.nodes).map(([, value]) => value).filter((node) => this.options.notAfter.includes(node.name));
+    return [
+      new Plugin4({
+        key: plugin,
+        appendTransaction: (_, __, state) => {
+          const { doc, tr, schema } = state;
+          const shouldInsertNodeAtEnd = plugin.getState(state);
+          const endPosition = doc.content.size;
+          const type = schema.nodes[this.options.node];
+          if (!shouldInsertNodeAtEnd) {
+            return;
+          }
+          return tr.insert(endPosition, type.create());
+        },
+        state: {
+          init: (_, state) => {
+            const lastNode = state.tr.doc.lastChild;
+            return !nodeEqualsType({ node: lastNode, types: disabledNodes });
+          },
+          apply: (tr, value) => {
+            if (!tr.docChanged) {
+              return value;
+            }
+            const lastNode = tr.doc.lastChild;
+            return !nodeEqualsType({ node: lastNode, types: disabledNodes });
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/SlashCommand/SlashCommand.ts
+import { Extension as Extension3 } from "@tiptap/core";
+import { ReactRenderer } from "@tiptap/react";
+import Suggestion from "@tiptap/suggestion";
+import { PluginKey as PluginKey3 } from "@tiptap/pm/state";
+
+// src/extensions/SlashCommand/BlockMenu.tsx
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { Menu, MenuGroup, MenuItem, MenuList, MenuPopover } from "@ablogcms/components/dropdown-menu";
+import { jsx } from "react/jsx-runtime";
+var BlockMenu = React.forwardRef(({ items, command, ...menuProps }, ref) => {
+  const scrollContainer = useRef(null);
+  const itemRefs = useRef([]);
+  const [selectedGroupIndex, setSelectedGroupIndex] = useState(0);
+  const [selectedCommandIndex, setSelectedCommandIndex] = useState(0);
+  useEffect(() => {
+    itemRefs.current = items.map((group) => new Array(group.commands.length).fill(null));
+    setSelectedGroupIndex(0);
+    setSelectedCommandIndex(0);
+  }, [items]);
+  const selectItem = useCallback(
+    (groupIndex, commandIndex) => {
+      const selectedCommand = items[groupIndex].commands[commandIndex];
+      command(selectedCommand);
+    },
+    [items, command]
+  );
+  React.useImperativeHandle(ref, () => ({
+    onKeyDown: ({ event }) => {
+      if (event.key === "ArrowDown") {
+        if (!items.length) {
+          return false;
+        }
+        const { commands } = items[selectedGroupIndex];
+        let newCommandIndex = selectedCommandIndex + 1;
+        let newGroupIndex = selectedGroupIndex;
+        if (commands.length - 1 < newCommandIndex) {
+          newCommandIndex = 0;
+          newGroupIndex = selectedGroupIndex + 1;
+        }
+        if (items.length - 1 < newGroupIndex) {
+          newGroupIndex = 0;
+        }
+        setSelectedCommandIndex(newCommandIndex);
+        setSelectedGroupIndex(newGroupIndex);
+        return true;
+      }
+      if (event.key === "ArrowUp") {
+        if (!items.length) {
+          return false;
+        }
+        let newCommandIndex = selectedCommandIndex - 1;
+        let newGroupIndex = selectedGroupIndex;
+        if (newCommandIndex < 0) {
+          newGroupIndex = selectedGroupIndex - 1;
+          const commandLength = items[newGroupIndex]?.commands?.length || 0;
+          newCommandIndex = commandLength > 0 ? commandLength - 1 : 0;
+        }
+        if (newGroupIndex < 0) {
+          newGroupIndex = items.length - 1;
+          newCommandIndex = items[newGroupIndex].commands.length - 1;
+        }
+        setSelectedCommandIndex(newCommandIndex);
+        setSelectedGroupIndex(newGroupIndex);
+        return true;
+      }
+      if (event.key === "Enter") {
+        if (!items.length || selectedGroupIndex === -1 || selectedCommandIndex === -1) {
+          return false;
+        }
+        selectItem(selectedGroupIndex, selectedCommandIndex);
+        return true;
+      }
+      return false;
+    }
+  }));
+  useEffect(() => {
+    const el = itemRefs.current[selectedGroupIndex]?.[selectedCommandIndex];
+    if (el) {
+      el.scrollIntoView({
+        block: "nearest",
+        behavior: "auto"
+      });
+    }
+  }, [selectedCommandIndex, selectedGroupIndex]);
+  const createCommandClickHandler = useCallback(
+    (groupIndex, commandIndex) => () => {
+      selectItem(groupIndex, commandIndex);
+    },
+    [selectItem]
+  );
+  if (!items.length) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    Menu,
+    {
+      ...menuProps,
+      focusManagerOptions: { initialFocus: -1 },
+      listNavigationOptions: { enabled: false },
+      children: /* @__PURE__ */ jsx(MenuPopover, { ref: scrollContainer, scrollable: true, "data-elevation": "3", children: /* @__PURE__ */ jsx(MenuList, { children: items.map((group, groupIndex) => /* @__PURE__ */ jsx(MenuGroup, { title: group.title, children: group.commands.map((command2, commandIndex) => /* @__PURE__ */ jsx(
+        MenuItem,
+        {
+          ref: (el) => {
+            if (!itemRefs.current[groupIndex]) {
+              itemRefs.current[groupIndex] = [];
+            }
+            itemRefs.current[groupIndex][commandIndex] = el;
+          },
+          isActive: selectedGroupIndex === groupIndex && selectedCommandIndex === commandIndex,
+          onSelect: createCommandClickHandler(groupIndex, commandIndex),
+          icon: /* @__PURE__ */ jsx(Icon, { name: command2.iconName }),
+          children: command2.label
+        },
+        `${command2.label}`
+      )) }, `${group.title}-group`)) }) })
+    }
+  );
+});
+BlockMenu.displayName = "BlockMenu";
+var BlockMenu_default = BlockMenu;
+
+// src/extensions/SlashCommand/SlashCommand.ts
+var commonMenuProps = {
+  isOpen: true,
+  strategy: "fixed",
+  placement: "bottom-start",
+  focusManagerOptions: {
+    initialFocus: -1
+  }
+};
+var extensionName = "slashCommand";
+var SlashCommand = Extension3.create({
+  name: extensionName,
+  priority: 200,
+  addOptions() {
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- configure() の getItems とシグネチャを一致させ options 型を正しく推論させるための引数
+      getItems: (_props) => []
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      Suggestion({
+        editor: this.editor,
+        char: "/",
+        allowSpaces: true,
+        startOfLine: true,
+        pluginKey: new PluginKey3(extensionName),
+        allow: ({ state, range }) => {
+          const $from = state.doc.resolve(range.from);
+          const isRootDepth = $from.depth === 1;
+          const isParagraph = $from.parent.type.name === "paragraph";
+          const isStartOfNode = $from.parent.textContent?.charAt(0) === "/";
+          const isInColumn = this.editor.isActive("column");
+          const afterContent = $from.parent.textContent?.substring($from.parent.textContent?.indexOf("/"));
+          const isValidAfterContent = !afterContent?.endsWith("  ");
+          return (isRootDepth && isParagraph && isStartOfNode || isInColumn && isParagraph && isStartOfNode) && isValidAfterContent;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        command: ({ editor, props }) => {
+          const { view, state } = editor;
+          const { $head, $from } = view.state.selection;
+          const end = $from.pos;
+          const from = $head?.nodeBefore ? end - ($head.nodeBefore.text?.substring($head.nodeBefore.text?.indexOf("/")).length ?? 0) : $from.start();
+          const tr = state.tr.deleteRange(from, end);
+          view.dispatch(tr);
+          props.action(editor);
+          view.focus();
+        },
+        items: ({ query, editor }) => {
+          return this.options.getItems({ query, editor });
+        },
+        render: () => {
+          let component = null;
+          let scrollHandler = null;
+          return {
+            onStart: (props) => {
+              component = new ReactRenderer(BlockMenu_default, {
+                props,
+                editor: props.editor
+              });
+              const { view } = props.editor;
+              const getAnchorRect = () => {
+                if (!props.clientRect) {
+                  return props.editor.storage[extensionName].rect;
+                }
+                const rect = props.clientRect();
+                if (!rect) {
+                  return props.editor.storage[extensionName].rect;
+                }
+                if (component === null) {
+                  return props.editor.storage[extensionName].rect;
+                }
+                const { element } = component;
+                if (!(element instanceof HTMLElement)) {
+                  return props.editor.storage[extensionName].rect;
+                }
+                let yPos = rect.y;
+                if (rect.top + element.offsetHeight + 40 > window.innerHeight) {
+                  const diff = rect.top + element.offsetHeight - window.innerHeight + 40;
+                  yPos = rect.y - diff;
+                }
+                return new DOMRect(rect.x, yPos, rect.width, rect.height);
+              };
+              scrollHandler = () => {
+                if (component === null) {
+                  return;
+                }
+                const newProps = {
+                  ...props,
+                  ...commonMenuProps,
+                  getAnchorRect
+                };
+                component.updateProps(newProps);
+              };
+              view.dom.parentElement?.addEventListener("scroll", scrollHandler);
+              component.updateProps({
+                ...props,
+                ...commonMenuProps,
+                getAnchorRect
+              });
+            },
+            onUpdate(props) {
+              if (component === null) {
+                return;
+              }
+              component.updateProps(props);
+              const { view } = props.editor;
+              const getAnchorRect = () => {
+                if (!props.clientRect) {
+                  return props.editor.storage[extensionName].rect;
+                }
+                const rect = props.clientRect();
+                if (!rect) {
+                  return props.editor.storage[extensionName].rect;
+                }
+                return new DOMRect(rect.x, rect.y, rect.width, rect.height);
+              };
+              const scrollHandler2 = () => {
+                if (component === null) {
+                  return;
+                }
+                component.updateProps({
+                  ...props,
+                  isOpen: true,
+                  getAnchorRect
+                });
+              };
+              view.dom.parentElement?.addEventListener("scroll", scrollHandler2);
+              props.editor.storage[extensionName].rect = props.clientRect ? getAnchorRect() : {
+                width: 0,
+                height: 0,
+                left: 0,
+                top: 0,
+                right: 0,
+                bottom: 0
+              };
+              const newProps = {
+                ...props,
+                ...commonMenuProps,
+                getAnchorRect
+              };
+              component.updateProps(newProps);
+            },
+            onKeyDown(props) {
+              if (props.event.key === "Escape") {
+                const newProps = {
+                  isOpen: false
+                };
+                component?.updateProps(newProps);
+                return true;
+              }
+              return component?.ref?.onKeyDown(props) || false;
+            },
+            onExit(props) {
+              if (scrollHandler) {
+                const { view } = props.editor;
+                view.dom.parentElement?.removeEventListener("scroll", scrollHandler);
+              }
+              if (component) {
+                component.destroy();
+              }
+            }
+          };
+        }
+      })
+    ];
+  },
+  addStorage() {
+    return {
+      rect: {
+        width: 0,
+        height: 0,
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0
+      }
+    };
+  }
+});
+var SlashCommand_default = SlashCommand;
+
+// src/extensions/FontStyle/FontStyle.ts
+import { Extension as Extension4 } from "@tiptap/core";
+import "@tiptap/extension-text-style";
+var FontStyle = Extension4.create({
+  name: "fontStyle",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: ["paragraph"],
+        attributes: {
+          class: {}
+        }
+      },
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            parseHTML: (element) => {
+              return element.getAttribute("data-font-size") || null;
+            },
+            renderHTML: (attributes) => {
+              if (!attributes.fontSize) {
+                return {};
+              }
+              return {
+                style: `font-size: ${attributes.fontSize}`,
+                // 表示用
+                "data-font-size": attributes.fontSize
+                // 復元用
+              };
+            }
+          },
+          fontFamily: {
+            parseHTML: (element) => element.getAttribute("data-font-family") || null,
+            renderHTML: (attributes) => {
+              if (!attributes.fontFamily) return {};
+              return {
+                style: `font-family: ${attributes.fontFamily.replace(/"/g, "'")}`,
+                "data-font-family": attributes.fontFamily.replace(/"/g, "'")
+              };
+            }
+          },
+          fontColor: {
+            parseHTML: (element) => element.getAttribute("data-font-color") || null,
+            renderHTML: (attributes) => {
+              if (!attributes.fontColor) return {};
+              return {
+                style: `color: ${attributes.fontColor}`,
+                "data-font-color": attributes.fontColor
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (fontSize) => ({ chain }) => chain().setMark("textStyle", { fontSize }).run(),
+      unsetFontSize: () => ({ chain }) => chain().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run(),
+      setFontFamily: (family) => ({ chain }) => chain().setMark("textStyle", { fontFamily: family }).run(),
+      unsetFontFamily: () => ({ chain }) => chain().setMark("textStyle", { fontFamily: null }).removeEmptyTextStyle().run(),
+      setFontColor: (color) => ({ chain }) => chain().setMark("textStyle", { fontColor: color }).run(),
+      unsetFontColor: () => ({ chain }) => chain().setMark("textStyle", { fontColor: null }).removeEmptyTextStyle().run()
+    };
+  }
+});
+
+// src/extensions/Figcaption/Figcaption.ts
+import { mergeAttributes as mergeAttributes4, Node as Node2 } from "@tiptap/core";
+
+// src/extensions/Image/Image.ts
+import { Image as BaseImage } from "@tiptap/extension-image";
+var Image = BaseImage.extend({
+  group: "block"
+});
+
+// src/extensions/Figcaption/Figcaption.ts
+var Figcaption = Node2.create({
+  name: "figcaption",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "inline*",
+  selectable: false,
+  draggable: false,
+  marks: "link",
+  parseHTML() {
+    return [
+      {
+        tag: "figcaption"
+      }
+    ];
+  },
+  addKeyboardShortcuts() {
+    return {
+      // On Enter at the end of line, create new paragraph and focus
+      Enter: ({ editor }) => {
+        const {
+          state: {
+            selection: { $from, empty }
+          }
+        } = editor;
+        if (!empty || $from.parent.type !== this.type) {
+          return false;
+        }
+        const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
+        if (!isAtEnd) {
+          return false;
+        }
+        const pos = editor.state.selection.$from.end();
+        return editor.chain().focus(pos).insertContentAt(pos, { type: "paragraph" }).run();
+      },
+      // On Backspace at the beginning of line,
+      // dont delete content of image before
+      Backspace: ({ editor }) => {
+        const {
+          state: {
+            selection: { $from, empty }
+          }
+        } = editor;
+        if (!empty || $from.parent.type !== this.type) {
+          return false;
+        }
+        const isAtStart = $from.parentOffset === 0;
+        if (!isAtStart) {
+          return false;
+        }
+        const nodeBefore = editor.state.doc.nodeAt($from.pos - 2);
+        if (nodeBefore?.type.name === Image.name) {
+          return true;
+        }
+        return false;
+      }
+    };
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["figcaption", mergeAttributes4(HTMLAttributes), 0];
+  }
+});
+
+// src/extensions/Link/Link.ts
+import { mergeAttributes as mergeAttributes5 } from "@tiptap/core";
+import { Link as TiptapLink } from "@tiptap/extension-link";
+import { Plugin as Plugin5 } from "@tiptap/pm/state";
+var ATTRIBUTE_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+var DEFAULT_ALLOWED_PROTOCOLS = ["http", "https", "ftp", "ftps", "mailto", "tel", "callto", "sms", "cid", "xmpp"];
+var escapeRegExp = (value) => value.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+function isAllowedBlockEditorLinkUri(uri, protocols) {
+  const allowedProtocols = [...DEFAULT_ALLOWED_PROTOCOLS];
+  if (protocols) {
+    protocols.forEach((protocol) => {
+      const nextProtocol = typeof protocol === "string" ? protocol : protocol.scheme;
+      if (nextProtocol) {
+        allowedProtocols.push(nextProtocol);
+      }
+    });
+  }
+  return !uri || uri.replace(ATTRIBUTE_WHITESPACE, "").match(
+    new RegExp(
+      `^(?:(?:${allowedProtocols.map(escapeRegExp).join("|")}):|[^a-z]|[a-z0-9+.\\-]+(?:[^a-z+.\\-:]|$))`,
+      "i"
+    )
+  );
+}
+var Link = TiptapLink.extend({
+  inclusive: false,
+  parseHTML() {
+    return [{ tag: 'a[href]:not([data-type="button"]):not([href *= "javascript:" i])' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const attrs = mergeAttributes5(this.options.HTMLAttributes, HTMLAttributes, { class: "link" });
+    if (!attrs.target) {
+      delete attrs.target;
+      delete attrs.rel;
+    }
+    return ["a", attrs, 0];
+  },
+  addProseMirrorPlugins() {
+    const { editor } = this;
+    return [
+      ...this.parent?.() || [],
+      new Plugin5({
+        props: {
+          handleKeyDown: (view, event) => {
+            const { selection } = editor.state;
+            if (event.key === "Escape" && selection.empty !== true) {
+              editor.commands.focus(selection.to, { scrollIntoView: false });
+            }
+            return false;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/ImageBlock/ImageBlock.ts
+import { ReactNodeViewRenderer } from "@tiptap/react";
+
+// src/extensions/ImageBlock/components/ImageBlockView.tsx
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { NodeViewWrapper } from "@tiptap/react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function ImageBlockView(props) {
+  const { editor, getPos, node } = props;
+  const imageWrapperRef = useRef2(null);
+  const { src, alt, caption, width, height, displayWidth, mediaId, align, link, target, entryId } = node.attrs;
+  const wrapperClassName = cn("media-image-block", `align-${align || "left"}`);
+  const figureClassName = cn(node.attrs.class);
+  const onClick = useCallback2(() => {
+    const pos = getPos();
+    if (pos === void 0) return;
+    editor.commands.setNodeSelection(pos);
+  }, [getPos, editor.commands]);
+  useEffect2(() => {
+    const listener = (event) => {
+      if (!(event instanceof CustomEvent)) {
+        return;
+      }
+      const media = event.detail.data;
+      if (parseInt(mediaId, 10) === media.media_id) {
+        if (media.media_thumbnail) {
+          editor.chain().updateAllMediaImageBlocks(media).run();
+        }
+      }
+    };
+    document.addEventListener("acms.media-updated", listener);
+    return () => {
+      document.removeEventListener("acms.media-updated", listener);
+    };
+  }, [mediaId, editor]);
+  return /* @__PURE__ */ jsx2(
+    NodeViewWrapper,
+    {
+      contentEditable: false,
+      className: wrapperClassName,
+      "data-type": "imageBlock",
+      "data-align": align || "left",
+      "data-link": link || null,
+      "data-width": displayWidth || "100%",
+      "data-eid": entryId || (typeof ACMS !== "undefined" ? ACMS.Config.eid : void 0),
+      "data-no-lightbox": node.attrs.noLightbox === "true" ? "true" : "false",
+      children: /* @__PURE__ */ jsxs(
+        "figure",
+        {
+          className: figureClassName,
+          contentEditable: false,
+          ref: imageWrapperRef,
+          style: { maxWidth: displayWidth },
+          children: [
+            link ? /* @__PURE__ */ jsx2(
+              "a",
+              {
+                href: link,
+                target: target || void 0,
+                rel: target ? "noopener noreferrer" : void 0,
+                onClick,
+                children: /* @__PURE__ */ jsx2(
+                  "img",
+                  {
+                    src,
+                    className: `unit-id-${entryId || (typeof ACMS !== "undefined" ? ACMS.Config.eid : "")}`,
+                    width: width || void 0,
+                    height: height || void 0,
+                    alt: alt || "",
+                    loading: "lazy",
+                    decoding: "async",
+                    "data-mid": mediaId || void 0,
+                    draggable: false
+                  }
+                )
+              }
+            ) : node.attrs.noLightbox !== "true" ? /* @__PURE__ */ jsx2("a", { href: src, onClick, children: /* @__PURE__ */ jsx2(
+              "img",
+              {
+                src,
+                className: `unit-id-${entryId || (typeof ACMS !== "undefined" ? ACMS.Config.eid : "")}`,
+                width: width || void 0,
+                height: height || void 0,
+                alt: alt || "",
+                loading: "lazy",
+                decoding: "async",
+                "data-mid": mediaId || void 0,
+                draggable: false
+              }
+            ) }) : /* @__PURE__ */ jsx2(
+              "img",
+              {
+                src,
+                className: `unit-id-${entryId || (typeof ACMS !== "undefined" ? ACMS.Config.eid : "")}`,
+                width: width || void 0,
+                height: height || void 0,
+                alt: alt || "",
+                loading: "lazy",
+                decoding: "async",
+                "data-mid": mediaId || void 0,
+                draggable: false,
+                role: "button",
+                tabIndex: 0,
+                onClick,
+                onKeyDown: (e) => {
+                  if (e.key === "Enter" || e.key === " ") {
+                    onClick();
+                  }
+                }
+              }
+            ),
+            caption && /* @__PURE__ */ jsx2("figcaption", { className: "caption", children: caption })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/extensions/mediaBlockContent.ts
+var createImageBlockAttrs = (mediaItem, className) => {
+  let width = null;
+  let height = null;
+  if (mediaItem.media_size.includes("x")) {
+    const [tempX, tempY] = mediaItem.media_size.split("x");
+    width = parseInt(tempX.trim(), 10);
+    height = parseInt(tempY.trim(), 10);
+  }
+  return {
+    src: mediaItem.media_root_path,
+    class: className || null,
+    mediaId: mediaItem.media_id,
+    entryId: ACMS.Config.eid,
+    width,
+    height,
+    link: mediaItem.media_link ?? null,
+    caption: mediaItem.media_caption ?? null,
+    alt: mediaItem.media_alt ?? null
+  };
+};
+var createFileBlockAttrs = (mediaItem, className) => ({
+  href: mediaItem.media_permalink,
+  icon: mediaItem.media_icon,
+  iconWidth: mediaItem.media_icon_width || "100",
+  iconHeight: mediaItem.media_icon_height || "100",
+  class: className || null,
+  mediaId: mediaItem.media_id,
+  caption: mediaItem.media_caption || mediaItem.media_title || null,
+  alt: mediaItem.media_alt || null,
+  extension: mediaItem.media_ext || null,
+  fileSize: mediaItem.media_filesize || null
+});
+var buildMediaBlockContent = (mediaItem, className, noLightbox) => {
+  if (mediaItem.media_type === "file") {
+    return { type: "fileBlock", attrs: createFileBlockAttrs(mediaItem, className) };
+  }
+  return { type: "imageBlock", attrs: { ...createImageBlockAttrs(mediaItem, className), noLightbox } };
+};
+
+// src/extensions/ImageBlock/ImageBlock.ts
+var ImageBlock = Image.extend({
+  name: "imageBlock",
+  group: "block",
+  atom: true,
+  defining: true,
+  isolating: true,
+  addOptions() {
+    return {
+      ...this.parent?.(),
+      getImageDefaultLightbox: () => true
+    };
+  },
+  addAttributes() {
+    return {
+      src: {
+        default: "",
+        renderHTML: (attributes) => ({
+          src: attributes.src
+        })
+      },
+      align: {
+        default: "center",
+        renderHTML: (attributes) => ({
+          "data-align": attributes.align
+        })
+      },
+      link: {
+        default: null,
+        renderHTML: (attributes) => ({
+          "data-link": attributes.link
+        })
+      },
+      target: {
+        default: null,
+        renderHTML: (attributes) => ({
+          "data-target": attributes.target
+        })
+      },
+      caption: {
+        default: void 0,
+        renderHTML: (attributes) => ({
+          "data-caption": attributes.caption
+        })
+      },
+      alt: {
+        default: void 0,
+        renderHTML: (attributes) => ({
+          alt: attributes.alt
+        })
+      },
+      width: {
+        default: null,
+        renderHTML: (attributes) => ({
+          width: attributes.width
+        })
+      },
+      height: {
+        default: null,
+        renderHTML: (attributes) => ({
+          height: attributes.height
+        })
+      },
+      displayWidth: {
+        default: "100%",
+        renderHTML: (attributes) => ({
+          "data-width": attributes.displayWidth
+        })
+      },
+      mediaId: {
+        default: null,
+        renderHTML: (attributes) => ({
+          "data-mid": attributes.mediaId || null
+        })
+      },
+      entryId: {
+        default: null,
+        renderHTML: (attributes) => ({
+          "data-eid": attributes.entryId || ACMS.Config.eid
+        })
+      },
+      noLightbox: {
+        default: "false",
+        renderHTML: (attributes) => ({
+          "data-no-lightbox": attributes.noLightbox === "true" ? "true" : "false"
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "figure",
+        getAttrs: (element) => {
+          const img = element.querySelector("img");
+          const figcaption = element.querySelector("figcaption");
+          const parent = element.closest(`[data-type="${this.name}"]`);
+          const link = parent?.querySelector("a");
+          return {
+            src: img?.getAttribute("src"),
+            align: parent?.getAttribute("data-align") || "center",
+            link: parent?.getAttribute("data-link"),
+            target: link?.target || null,
+            caption: figcaption?.textContent?.trim() || "",
+            alt: img?.getAttribute("alt"),
+            width: img?.getAttribute("width"),
+            height: img?.getAttribute("height"),
+            displayWidth: parent?.getAttribute("data-width"),
+            mediaId: img?.getAttribute("data-mid"),
+            entryId: parent?.getAttribute("data-eid"),
+            noLightbox: parent?.getAttribute("data-no-lightbox") === "true" ? "true" : "false"
+          };
+        }
+      },
+      {
+        tag: "img",
+        getAttrs: (element) => {
+          if (element.closest('[data-type="fileBlock"]')) {
+            return false;
+          }
+          return {
+            src: element.getAttribute("src"),
+            align: "center",
+            link: "",
+            target: null,
+            caption: "",
+            alt: element.getAttribute("alt"),
+            width: element.getAttribute("width"),
+            height: element.getAttribute("height"),
+            displayWidth: "",
+            mediaId: null,
+            entryId: null,
+            noLightbox: "false"
+          };
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const id = HTMLAttributes.id || null;
+    const className = HTMLAttributes.class || "";
+    const src = HTMLAttributes.src || "";
+    const align = HTMLAttributes["data-align"] || "left";
+    const link = HTMLAttributes["data-link"] || null;
+    const target = HTMLAttributes["data-target"] || null;
+    const caption = HTMLAttributes["data-caption"] || null;
+    const alt = HTMLAttributes.alt || null;
+    const width = HTMLAttributes.width || null;
+    const height = HTMLAttributes.height || null;
+    const displayWidth = HTMLAttributes["data-width"] || "100%";
+    const mediaId = HTMLAttributes["data-mid"] || null;
+    const eid = HTMLAttributes["data-eid"] || ACMS.Config.eid;
+    const shouldUseLightbox = HTMLAttributes["data-no-lightbox"] !== "true";
+    const img = [
+      "img",
+      {
+        src,
+        class: `unit-id-${eid}`,
+        width,
+        height,
+        alt,
+        loading: "lazy",
+        decoding: "async",
+        "data-mid": mediaId || null
+      }
+    ];
+    let anchor = img;
+    if (link) {
+      anchor = [
+        "a",
+        {
+          href: link,
+          ...target ? {
+            target,
+            rel: "noopener noreferrer"
+          } : {}
+        },
+        img
+      ];
+    } else if (shouldUseLightbox) {
+      anchor = [
+        "a",
+        {
+          href: src
+        },
+        img
+      ];
+    }
+    const figureChildren = [anchor];
+    if (caption) {
+      figureChildren.push([
+        "figcaption",
+        {
+          class: "caption"
+        },
+        caption
+      ]);
+    }
+    return [
+      "div",
+      {
+        class: `media-image-block align-${align}`,
+        "data-type": this.name,
+        "data-align": align,
+        "data-link": link || null,
+        "data-width": displayWidth,
+        "data-eid": eid,
+        "data-no-lightbox": shouldUseLightbox ? "false" : "true"
+      },
+      [
+        "figure",
+        {
+          id,
+          class: className,
+          style: `max-width: ${displayWidth};`
+        },
+        ...figureChildren
+      ]
+    ];
+  },
+  addCommands() {
+    const defaultNoLightbox = () => this.options.getImageDefaultLightbox() ? "false" : "true";
+    return {
+      setImageBlock: (attrs) => ({ commands }) => commands.insertContent({ type: "imageBlock", attrs: { src: attrs.src, noLightbox: defaultNoLightbox() } }),
+      setImageBlockAt: (attrs) => ({ commands }) => commands.insertContentAt(attrs.pos, {
+        type: "imageBlock",
+        attrs: { src: attrs.src, noLightbox: defaultNoLightbox() }
+      }),
+      setImageBlockAlign: (align) => ({ commands }) => commands.updateAttributes("imageBlock", { align }),
+      setImageBlockWidth: (width) => ({ commands }) => commands.updateAttributes("imageBlock", { displayWidth: width }),
+      setImageBlockLink: (link, openInNewTab = false) => ({ commands }) => commands.updateAttributes("imageBlock", { link, target: openInNewTab ? "_blank" : null }),
+      setImageBlockCaption: (caption) => ({ commands }) => commands.updateAttributes("imageBlock", { caption }),
+      setImageBlockAlt: (alt) => ({ commands }) => commands.updateAttributes("imageBlock", { alt }),
+      setMediaImageBlock: (mediaItem, className) => ({ commands }) => commands.insertContent({
+        type: "imageBlock",
+        attrs: { ...createImageBlockAttrs(mediaItem, className), noLightbox: defaultNoLightbox() }
+      }),
+      updateMediaImageBlock: (mediaItem) => ({ commands }) => commands.updateAttributes("imageBlock", createImageBlockAttrs(mediaItem)),
+      updateAllMediaImageBlocks: (mediaItem) => ({ state, dispatch }) => {
+        if (!dispatch) return false;
+        const newAttrs = createImageBlockAttrs(mediaItem);
+        const targetMediaId = mediaItem.media_id;
+        const positions = [];
+        state.doc.descendants((node, pos) => {
+          if (node.type.name === "imageBlock") {
+            const nodeMediaId = typeof node.attrs.mediaId === "string" ? parseInt(node.attrs.mediaId, 10) : node.attrs.mediaId;
+            if (nodeMediaId === targetMediaId) {
+              positions.push(pos);
+            }
+          }
+        });
+        if (positions.length > 0) {
+          const { tr } = state;
+          positions.forEach((pos) => {
+            const node = state.doc.nodeAt(pos);
+            if (node && node.type.name === "imageBlock") {
+              tr.setNodeMarkup(pos, void 0, { ...node.attrs, ...newAttrs });
+            }
+          });
+          dispatch(tr);
+          return true;
+        }
+        return false;
+      },
+      toggleImageBlockLightbox: () => ({ editor, commands }) => {
+        const { noLightbox } = editor.getAttributes("imageBlock");
+        return commands.updateAttributes("imageBlock", {
+          noLightbox: noLightbox === "true" ? "false" : "true"
+        });
+      }
+    };
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(ImageBlockView);
+  }
+});
+
+// src/extensions/FileBlock/FileBlock.ts
+import { ReactNodeViewRenderer as ReactNodeViewRenderer2 } from "@tiptap/react";
+
+// src/extensions/FileBlock/components/FileBlockView.tsx
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3 } from "react";
+import { NodeViewWrapper as NodeViewWrapper2 } from "@tiptap/react";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function FileBlockView(props) {
+  const { editor, getPos, node } = props;
+  const fileWrapperRef = useRef3(null);
+  const {
+    displayType,
+    href,
+    target,
+    icon,
+    iconWidth,
+    iconHeight,
+    extension,
+    fileSize,
+    mediaId,
+    alt,
+    caption,
+    align,
+    id
+  } = node.attrs;
+  const cleanedClassNames = String(node.attrs.class ?? "").split(/\s+/).filter((cls) => !["align-left", "align-center", "align-right"].includes(cls)).join(" ").trim();
+  const wrapperClassName = cn("media-file-block", `align-${align || "left"}`, cleanedClassNames);
+  const onClick = useCallback3(
+    (event) => {
+      event.preventDefault();
+      const pos = getPos();
+      if (pos === void 0) return;
+      editor.commands.setNodeSelection(pos);
+    },
+    [getPos, editor.commands]
+  );
+  useEffect3(() => {
+    const listener = (event) => {
+      if (!(event instanceof CustomEvent)) {
+        return;
+      }
+      const media = event.detail.data;
+      if (parseInt(mediaId, 10) === media.media_id) {
+        editor.chain().updateAllMediaFileBlocks(media).run();
+      }
+    };
+    document.addEventListener("acms.media-updated", listener);
+    return () => {
+      document.removeEventListener("acms.media-updated", listener);
+    };
+  }, [mediaId, editor]);
+  return /* @__PURE__ */ jsx3(
+    NodeViewWrapper2,
+    {
+      contentEditable: false,
+      "data-type": "fileBlock",
+      id,
+      className: wrapperClassName,
+      "data-display-type": displayType || "icon",
+      "data-icon": icon || "",
+      "data-icon-width": iconWidth || "100",
+      "data-icon-height": iconHeight || "100",
+      "data-alt": alt ?? void 0,
+      "data-caption": caption ?? void 0,
+      "data-align": align || "left",
+      "data-mid": mediaId ?? void 0,
+      "data-extension": extension ?? void 0,
+      "data-file-size": fileSize ?? void 0,
+      children: /* @__PURE__ */ jsx3("div", { className: "acms-admin-block-editor-file", contentEditable: false, ref: fileWrapperRef, children: displayType === "button" ? /* @__PURE__ */ jsxs2(
+        "a",
+        {
+          href,
+          target: target || void 0,
+          rel: target ? "noopener noreferrer" : void 0,
+          onClick,
+          children: [
+            /* @__PURE__ */ jsx3(
+              "img",
+              {
+                src: icon,
+                width: iconWidth,
+                height: iconHeight,
+                alt: alt || "",
+                loading: "lazy",
+                decoding: "async",
+                draggable: false
+              }
+            ),
+            /* @__PURE__ */ jsx3("p", { className: "caption", children: caption || "" })
+          ]
+        }
+      ) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+        /* @__PURE__ */ jsx3(
+          "a",
+          {
+            href,
+            target: target || void 0,
+            rel: target ? "noopener noreferrer" : void 0,
+            onClick,
+            children: /* @__PURE__ */ jsx3(
+              "img",
+              {
+                src: icon,
+                width: iconWidth,
+                height: iconHeight,
+                alt: alt || "",
+                loading: "lazy",
+                decoding: "async",
+                draggable: false
+              }
+            )
+          }
+        ),
+        caption && /* @__PURE__ */ jsx3("p", { className: "caption", children: caption })
+      ] }) })
+    }
+  );
+}
+
+// src/extensions/FileBlock/FileBlock.ts
+var FileBlock = ImageBlock.extend({
+  name: "fileBlock",
+  group: "block",
+  atom: true,
+  defining: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      displayType: {
+        default: "icon",
+        renderHTML: (attrs) => ({
+          "data-display-type": attrs.displayType || "icon"
+        })
+      },
+      href: {
+        default: "",
+        renderHTML: (attrs) => ({
+          "data-href": attrs.href || ""
+        })
+      },
+      icon: {
+        default: "",
+        renderHTML: (attrs) => ({
+          "data-icon": attrs.icon || ""
+        })
+      },
+      iconWidth: {
+        default: "",
+        renderHTML: (attrs) => ({
+          "data-icon-width": attrs.iconWidth || ""
+        })
+      },
+      iconHeight: {
+        default: "",
+        renderHTML: (attrs) => ({
+          "data-icon-height": attrs.iconHeight || ""
+        })
+      },
+      extension: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-extension": attrs.extension ?? null
+        })
+      },
+      fileSize: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-file-size": attrs.fileSize ?? null
+        })
+      },
+      align: {
+        default: "left",
+        renderHTML: (attrs) => ({
+          "data-align": attrs.align ?? "left"
+        })
+      },
+      target: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-target": attrs.target ?? null
+        })
+      },
+      caption: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-caption": attrs.caption ?? ""
+        })
+      },
+      alt: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-alt": attrs.alt ?? ""
+        })
+      },
+      mediaId: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-mid": attrs.mediaId ?? null
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+        getAttrs: (element) => {
+          const link = element.querySelector("a");
+          return {
+            displayType: element?.getAttribute("data-display-type") || "icon",
+            href: link?.getAttribute("href"),
+            icon: element?.getAttribute("data-icon") || "",
+            iconWidth: element?.getAttribute("data-icon-width") || "100",
+            iconHeight: element?.getAttribute("data-icon-height") || "100",
+            extension: element?.getAttribute("data-extension") ?? null,
+            fileSize: element?.getAttribute("data-file-size") ?? null,
+            align: element?.getAttribute("data-align") || "center",
+            target: link?.target || null,
+            caption: element?.getAttribute("data-caption") || null,
+            alt: element?.getAttribute("data-alt"),
+            mediaId: element?.getAttribute("data-mid")
+          };
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const id = HTMLAttributes.id || null;
+    const className = HTMLAttributes.class || "";
+    const displayType = HTMLAttributes["data-display-type"] || "icon";
+    const href = HTMLAttributes["data-href"] || "";
+    const icon = HTMLAttributes["data-icon"] || "";
+    const iconWidth = HTMLAttributes["data-icon-width"] || "100";
+    const iconHeight = HTMLAttributes["data-icon-height"] || "100";
+    const extension = HTMLAttributes["data-extension"] || null;
+    const fileSize = HTMLAttributes["data-file-size"] || null;
+    const align = HTMLAttributes["data-align"] || "left";
+    const target = HTMLAttributes["data-target"] || null;
+    const caption = HTMLAttributes["data-caption"] || null;
+    const alt = HTMLAttributes["data-alt"] || null;
+    const mediaId = HTMLAttributes["data-mid"] || null;
+    const iconLink = [
+      [
+        "a",
+        {
+          href,
+          ...target ? {
+            target,
+            rel: "noopener noreferrer"
+          } : {}
+        },
+        [
+          "img",
+          {
+            src: icon,
+            width: iconWidth,
+            height: iconHeight,
+            alt: alt || "",
+            loading: "lazy",
+            decoding: "async"
+          }
+        ]
+      ]
+    ];
+    if (caption) {
+      iconLink.push(["p", { class: "caption" }, caption]);
+    }
+    const buttonLink = [
+      [
+        "a",
+        {
+          href,
+          ...target ? {
+            target,
+            rel: "noopener noreferrer"
+          } : {}
+        },
+        [
+          "img",
+          {
+            src: icon,
+            width: iconWidth,
+            height: iconHeight,
+            alt: alt || "",
+            loading: "lazy",
+            decoding: "async"
+          }
+        ],
+        ["p", { class: "caption" }, caption || ""]
+      ]
+    ];
+    const cleanedClassNames = className.split(/\s+/).filter((cls) => !["align-left", "align-center", "align-right"].includes(cls));
+    const classList = /* @__PURE__ */ new Set(["media-file-block", `align-${align}`, ...cleanedClassNames]);
+    const finalClass = Array.from(classList).join(" ");
+    const html = displayType === "button" ? buttonLink : iconLink;
+    return [
+      "div",
+      {
+        id,
+        class: finalClass,
+        "data-type": this.name,
+        "data-display-type": displayType,
+        "data-icon": icon,
+        "data-icon-width": iconWidth,
+        "data-icon-height": iconHeight,
+        "data-alt": alt,
+        "data-caption": caption,
+        "data-align": align,
+        "data-mid": mediaId,
+        "data-extension": extension,
+        "data-file-size": fileSize
+      },
+      ["div", {}, ...html]
+    ];
+  },
+  addCommands() {
+    return {
+      setFileBlock: (attrs) => ({ commands }) => commands.insertContent({ type: "fileBlock", attrs: { src: attrs.src } }),
+      setFileBlockAt: (attrs) => ({ commands }) => commands.insertContentAt(attrs.pos, { type: "fileBlock", attrs: { src: attrs.src } }),
+      setFileBlockDisplayType: (displayType) => ({ commands }) => commands.updateAttributes("fileBlock", { displayType }),
+      setFileBlockAlign: (align) => ({ commands }) => commands.updateAttributes("fileBlock", { align }),
+      setFileBlockCaption: (caption) => ({ commands }) => commands.updateAttributes("fileBlock", { caption }),
+      setFileBlockAlt: (alt) => ({ commands }) => commands.updateAttributes("fileBlock", { alt }),
+      setMediaFileBlock: (mediaItem, className) => ({ commands }) => commands.insertContent({
+        type: "fileBlock",
+        attrs: createFileBlockAttrs(mediaItem, className)
+      }),
+      updateMediaFileBlock: (mediaItem) => ({ commands }) => commands.updateAttributes("fileBlock", createFileBlockAttrs(mediaItem)),
+      updateAllMediaFileBlocks: (mediaItem) => ({ state, dispatch }) => {
+        if (!dispatch) return false;
+        const newAttrs = createFileBlockAttrs(mediaItem);
+        const targetMediaId = mediaItem.media_id;
+        const positions = [];
+        state.doc.descendants((node, pos) => {
+          if (node.type.name === "fileBlock") {
+            const nodeMediaId = typeof node.attrs.mediaId === "string" ? parseInt(node.attrs.mediaId, 10) : node.attrs.mediaId;
+            if (nodeMediaId === targetMediaId) {
+              positions.push(pos);
+            }
+          }
+        });
+        if (positions.length > 0) {
+          const { tr } = state;
+          positions.forEach((pos) => {
+            const node = state.doc.nodeAt(pos);
+            if (node && node.type.name === "fileBlock") {
+              tr.setNodeMarkup(pos, void 0, { ...node.attrs, ...newAttrs });
+            }
+          });
+          dispatch(tr);
+          return true;
+        }
+        return false;
+      },
+      toggleFileBlockTarget: () => ({ commands }) => {
+        const { target } = this.editor.getAttributes("fileBlock");
+        const newTarget = target === "_blank" ? null : "_blank";
+        return commands.updateAttributes("fileBlock", { target: newTarget });
+      }
+    };
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer2(FileBlockView);
+  }
+});
+
+// src/extensions/PasteHandler/PasteHandler.ts
+import { Extension as Extension5 } from "@tiptap/core";
+import { Plugin as Plugin6 } from "@tiptap/pm/state";
+import { DOMParser as PMDOMParser } from "@tiptap/pm/model";
+import { fetchClient } from "@ablogcms/fetch-client";
+async function convertImgSrcToRelative(img) {
+  const src = img.getAttribute("src");
+  if (!src || !/^https?:\/\//i.test(src)) {
+    return;
+  }
+  try {
+    const root = ACMS.Config.root.replace(/\/$/, "");
+    const url = new URL(src);
+    const relativePath = url.pathname;
+    const checkUrl = `${location.origin}${root}${relativePath}`;
+    const res = await fetch(checkUrl, { method: "HEAD" });
+    if (res.ok) {
+      img.setAttribute("src", `${root}${relativePath}`);
+    }
+  } catch (e) {
+    console.warn("\u30DA\u30FC\u30B9\u30C8\u753B\u50CF\u306EURL\u5909\u63DB\u51E6\u7406\u306B\u5931\u6557\u3057\u307E\u3057\u305F:", e);
+  }
+}
+async function fetchMediaItem(mediaId) {
+  const endpoint = ACMS.Library.acmsLink({
+    tpl: "ajax/edit/media-edit.json",
+    bid: ACMS.Config.bid,
+    searchParams: { _mid: mediaId }
+  });
+  try {
+    const res = await fetchClient.get(
+      endpoint
+    );
+    return res.data.status === "success" ? res.data.item : null;
+  } catch {
+    return null;
+  }
+}
+function stripResizePrefix(imgPath) {
+  const lastSlash = imgPath.lastIndexOf("/");
+  const dir = lastSlash >= 0 ? imgPath.slice(0, lastSlash + 1) : "";
+  const basename = lastSlash >= 0 ? imgPath.slice(lastSlash + 1) : imgPath;
+  const match = basename.match(/^mode\d+_[^-]*-(.+)$/);
+  if (!match) return imgPath;
+  return dir + match[1];
+}
+async function checkImgMediaExists(img) {
+  const mediaId = img.getAttribute("data-mid");
+  if (!mediaId) {
+    return null;
+  }
+  const item = await fetchMediaItem(parseInt(mediaId, 10));
+  if (!item) {
+    return null;
+  }
+  const mediaPath = item.media_root_path.split("?")[0];
+  const imgPath = (img.getAttribute("src") ?? "").split("?")[0];
+  if (mediaPath === imgPath || mediaPath === stripResizePrefix(imgPath)) {
+    return item;
+  }
+  return null;
+}
+async function checkFileMediaExists(el) {
+  const mediaId = el.getAttribute("data-mid");
+  if (!mediaId) {
+    return false;
+  }
+  const item = await fetchMediaItem(parseInt(mediaId, 10));
+  if (!item) {
+    return false;
+  }
+  const permalink = item.media_permalink.split("?")[0];
+  const link = el.querySelector("a");
+  if (link === null) {
+    return false;
+  }
+  const href = (link.getAttribute("href") ?? "").split("?")[0];
+  if (permalink !== href) {
+    return false;
+  }
+  return true;
+}
+var pastePlugin = (editor) => new Plugin6({
+  props: {
+    handlePaste(view, event) {
+      const html = event.clipboardData?.getData("text/html");
+      if (!html) {
+        return false;
+      }
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(html, "text/html");
+      const fileBlocks = Array.from(doc.querySelectorAll('div[data-type="fileBlock"]'));
+      const imgs = Array.from(doc.querySelectorAll("img"));
+      if (fileBlocks.length === 0 && imgs.length === 0) {
+        return false;
+      }
+      const fileBlockChecks = fileBlocks.map(async (el) => {
+        if (el.hasAttribute("data-mid")) {
+          const mediaExists = await checkFileMediaExists(el);
+          if (!mediaExists) {
+            el.removeAttribute("data-mid");
+          }
+        }
+      });
+      const standaloneImgs = imgs.filter((img) => !img.closest('div[data-type="fileBlock"]'));
+      const imgChecks = standaloneImgs.map(async (img) => {
+        await convertImgSrcToRelative(img);
+        if (img.hasAttribute("data-mid")) {
+          const mediaItem = await checkImgMediaExists(img);
+          if (mediaItem !== null) {
+            img.setAttribute("src", mediaItem.media_root_path);
+          } else {
+            img.removeAttribute("data-mid");
+          }
+        }
+      });
+      Promise.all([...fileBlockChecks, ...imgChecks]).then(() => {
+        const slice = PMDOMParser.fromSchema(editor.schema).parseSlice(doc.body);
+        const transaction = view.state.tr.replaceSelection(slice);
+        view.dispatch(transaction);
+      });
+      return true;
+    }
+  }
+});
+var PasteHandler = Extension5.create({
+  name: "pasteHandler",
+  addProseMirrorPlugins() {
+    return [pastePlugin(this.editor)];
+  }
+});
+
+// src/extensions/LinkButton/LinkButton.ts
+import { ReactNodeViewRenderer as ReactNodeViewRenderer3 } from "@tiptap/react";
+import { Selection as Selection2 } from "@tiptap/pm/state";
+
+// src/extensions/LinkButton/components/LinkButtonView.tsx
+import { NodeViewWrapper as NodeViewWrapper3, NodeViewContent } from "@tiptap/react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var SpanNodeViewContent = NodeViewContent;
+function LinkButtonView(props) {
+  const { node } = props;
+  const { href, align, target } = node.attrs;
+  const cleanedClassNames = String(node.attrs.class ?? "").split(/\s+/).filter((cls) => !["align-left", "align-center", "align-right"].includes(cls)).join(" ").trim();
+  const wrapperClassName = cn(
+    "link-button-block",
+    "acms-admin-block-editor-link-button",
+    // 3.2.0 ~ 3.2.7 互換性のために残しておく
+    `align-${align || "center"}`,
+    cleanedClassNames
+  );
+  const showPlaceholder = node.content.size === 0;
+  const justifyContentMap = {
+    left: "flex-start",
+    center: "center",
+    right: "flex-end"
+  };
+  const wrapperStyle = {
+    display: "flex",
+    justifyContent: justifyContentMap[align || "center"]
+  };
+  return /* @__PURE__ */ jsx4(
+    NodeViewWrapper3,
+    {
+      className: wrapperClassName,
+      style: wrapperStyle,
+      "data-type": "linkButton",
+      "data-align": align || "center",
+      children: /* @__PURE__ */ jsx4(
+        "a",
+        {
+          href: href || "",
+          className: "link-button-block-link acms-admin-block-editor-link-button-link",
+          "data-type": "button",
+          target: target || void 0,
+          rel: target ? "noopener noreferrer" : void 0,
+          children: /* @__PURE__ */ jsx4(
+            SpanNodeViewContent,
+            {
+              as: "span",
+              style: showPlaceholder ? { minWidth: "1px" } : void 0,
+              className: showPlaceholder ? "is-empty" : void 0
+            }
+          )
+        }
+      )
+    }
+  );
+}
+
+// src/extensions/LinkButton/LinkButton.ts
+var LinkButton = ImageBlock.extend({
+  name: "linkButton",
+  group: "block",
+  content: "inline*",
+  atom: false,
+  selectable: true,
+  defining: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      href: {
+        default: "",
+        renderHTML: (attrs) => ({
+          "data-href": attrs.href || ""
+        })
+      },
+      align: {
+        default: "center",
+        renderHTML: (attrs) => ({
+          "data-align": attrs.align ?? "center"
+        })
+      },
+      target: {
+        default: null,
+        renderHTML: (attrs) => ({
+          "data-target": attrs.target ?? null
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+        getAttrs: (element) => {
+          const link = element.querySelector("a");
+          return {
+            href: link?.getAttribute("href"),
+            align: element?.getAttribute("data-align") || "center",
+            target: link?.target || null
+          };
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const id = HTMLAttributes.id || null;
+    const className = HTMLAttributes.class || "";
+    const href = HTMLAttributes["data-href"] || "";
+    const align = HTMLAttributes["data-align"] || "center";
+    const target = HTMLAttributes["data-target"] || null;
+    const linkButton = [
+      "a",
+      {
+        href,
+        class: "link-button-block-link",
+        "data-type": "button",
+        ...target ? {
+          target,
+          rel: "noopener noreferrer"
+        } : {}
+      },
+      0
+    ];
+    const cleanedClassNames = className.split(/\s+/).filter((cls) => !["align-left", "align-center", "align-right"].includes(cls));
+    const classList = /* @__PURE__ */ new Set(["link-button-block", `align-${align}`, ...cleanedClassNames]);
+    const finalClass = Array.from(classList).join(" ");
+    return [
+      "div",
+      {
+        id,
+        class: finalClass,
+        "data-type": this.name,
+        "data-align": align
+      },
+      linkButton
+    ];
+  },
+  addCommands() {
+    return {
+      setLinkButtonBlock: () => ({ commands }) => commands.insertContent({ type: "linkButton" }),
+      setLinkButtonBlockAt: (attrs) => ({ commands }) => commands.insertContentAt(attrs.pos, { type: "linkButton" }),
+      setLinkButtonBlockAlign: (align) => ({ commands }) => commands.updateAttributes("linkButton", { align }),
+      setLinkButtonBlockLink: (link, openInNewTab = false) => ({ commands }) => commands.updateAttributes("linkButton", { href: link, target: openInNewTab ? "_blank" : null })
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: ({ editor }) => {
+        const { state, dispatch } = editor.view;
+        const { tr, selection } = state;
+        const { $from } = selection;
+        for (let { depth } = $from; depth >= 0; depth--) {
+          const node = $from.node(depth);
+          if (node.type.name === "linkButton") {
+            const pos = $from.after(depth);
+            const paragraph = editor.schema.nodes.paragraph.create();
+            tr.insert(pos, paragraph);
+            const resolvedPos = tr.doc.resolve(pos);
+            const newSelection = Selection2.near(resolvedPos);
+            tr.setSelection(newSelection).scrollIntoView();
+            dispatch(tr);
+            return true;
+          }
+        }
+        return false;
+      },
+      Backspace: ({ editor }) => {
+        const { state, dispatch } = editor.view;
+        const { selection } = state;
+        const { $from } = selection;
+        for (let { depth } = $from; depth >= 0; depth--) {
+          const node = $from.node(depth);
+          if (node.type.name === "linkButton") {
+            const pos = $from.before(depth);
+            const isEmpty = node.content.size === 0;
+            const isAtStart = $from.pos === pos + 1;
+            if (isEmpty && isAtStart) {
+              const tr = state.tr.delete(pos, pos + node.nodeSize);
+              dispatch(tr.scrollIntoView());
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+    };
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer3(LinkButtonView);
+  }
+});
+
+// src/extensions/MultiColumn/Column.ts
+import { Node as Node3, mergeAttributes as mergeAttributes6 } from "@tiptap/core";
+var Column = Node3.create({
+  name: "column",
+  content: "block+",
+  isolating: true,
+  addAttributes() {
+    return {
+      position: {
+        default: "",
+        parseHTML: (element) => element.getAttribute("data-position"),
+        renderHTML: (attributes) => ({ "data-position": attributes.position })
+      }
+    };
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes6(HTMLAttributes, { "data-type": "column" }), 0];
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="column"]'
+      }
+    ];
+  }
+});
+
+// src/extensions/MediaUpload/MediaUpload.ts
+import { Node as Node4, ReactNodeViewRenderer as ReactNodeViewRenderer4 } from "@tiptap/react";
+import { Plugin as Plugin7 } from "@tiptap/pm/state";
+
+// src/extensions/MediaUpload/view/Dropzone.tsx
+import { useCallback as useCallback5, useEffect as useEffect4, useMemo } from "react";
+import { NodeViewWrapper as NodeViewWrapper4 } from "@tiptap/react";
+import MediaInsert from "@ablogcms/media/components/media-insert/media-insert";
+import { ButtonV2 as Button } from "@ablogcms/components/button-v2";
+import { DropZone } from "@ablogcms/components/drop-zone";
+
+// src/extensions/MediaUpload/view/hooks.ts
+import { useState as useState2, useCallback as useCallback4, useRef as useRef4 } from "react";
+var useMediaSelect = () => {
+  const [dropAreaState, setDropAreaState] = useState2({
+    isInsertModalOpen: false,
+    files: [],
+    tab: "upload"
+  });
+  const uploadFile = useCallback4((files) => {
+    setDropAreaState((prevState) => ({
+      ...prevState,
+      isInsertModalOpen: true,
+      files,
+      tab: "upload"
+    }));
+  }, []);
+  const handleModalClose = () => {
+    setDropAreaState((prevState) => ({
+      ...prevState,
+      isInsertModalOpen: false
+    }));
+  };
+  const handleSelectClick = useCallback4(() => {
+    setDropAreaState((prevState) => ({
+      ...prevState,
+      isInsertModalOpen: true,
+      files: [],
+      tab: "select"
+    }));
+  }, []);
+  return {
+    isInsertModalOpen: dropAreaState.isInsertModalOpen,
+    files: dropAreaState.files,
+    tab: dropAreaState.tab,
+    uploadFile,
+    handleModalClose,
+    handleSelectClick
+  };
+};
+var useFileUpload = ({ uploader }) => {
+  const fileInputRef = useRef4(null);
+  const handleUploadClick = useCallback4(() => {
+    fileInputRef.current?.click();
+  }, []);
+  const handleUploadFile = (e) => {
+    const { files } = e.target;
+    if (files && files instanceof FileList) {
+      uploader(Array.from(files));
+    }
+  };
+  return { fileInputRef, handleUploadClick, handleUploadFile };
+};
+var useDropZone = ({ uploader }) => {
+  const onDrop = (files) => {
+    uploader(files.map((item) => item.file));
+  };
+  return { onDrop };
+};
+
+// src/extensions/MediaUpload/view/insertMediaBlocks.ts
+var isImageMedia = (item) => item.media_type === "image" || item.media_type === "svg";
+var selectInsertableMedia = (items, accept) => items.filter((item) => {
+  if (accept === "image") {
+    return isImageMedia(item) && Boolean(item.media_thumbnail);
+  }
+  if (accept === "file") {
+    return !isImageMedia(item);
+  }
+  return isImageMedia(item) ? Boolean(item.media_thumbnail) : true;
+});
+var getImageDefaultNoLightbox = (editor) => {
+  const extension = editor.extensionManager.extensions.find((ext) => ext.name === "imageBlock");
+  const getter = extension?.options?.getImageDefaultLightbox;
+  return typeof getter === "function" && getter() ? "false" : "true";
+};
+var insertMediaBlocks = (editor, items, accept, className, range) => {
+  const targets = selectInsertableMedia(items, accept);
+  if (targets.length === 0) {
+    return 0;
+  }
+  const noLightbox = getImageDefaultNoLightbox(editor);
+  const contents = targets.map((item) => buildMediaBlockContent(item, className, noLightbox));
+  editor.chain().insertContentAt(range, contents).focus().run();
+  return targets.length;
+};
+
+// src/extensions/MediaUpload/view/filterFilesByMediaType.ts
+import { isImageFile } from "@ablogcms/lib/read-files";
+var filterFilesByMediaType = (files, accept) => {
+  if (accept === "image") {
+    return files.filter((file) => isImageFile(file));
+  }
+  if (accept === "file") {
+    return files.filter((file) => !isImageFile(file));
+  }
+  return [...files];
+};
+
+// src/extensions/MediaUpload/view/Dropzone.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function Dropzone({
+  getPos,
+  editor,
+  node
+}) {
+  const className = node?.attrs?.class || "";
+  const { isInsertModalOpen, files, tab, uploadFile, handleModalClose, handleSelectClick } = useMediaSelect();
+  const pastedFiles = useMemo(() => {
+    return node.attrs.__pastedFiles || [];
+  }, [node.attrs.__pastedFiles]);
+  const mediaType = useMemo(() => {
+    if (node.attrs.__mediaType === "file") return "file";
+    if (node.attrs.__mediaType === "all") return "all";
+    return "image";
+  }, [node.attrs.__mediaType]);
+  const acceptUpload = useCallback5(
+    (uploadingFiles) => {
+      const accepted = filterFilesByMediaType(uploadingFiles, mediaType);
+      if (accepted.length > 0) {
+        uploadFile(accepted);
+      }
+    },
+    [mediaType, uploadFile]
+  );
+  const { fileInputRef, handleUploadClick, handleUploadFile } = useFileUpload({ uploader: acceptUpload });
+  const { onDrop } = useDropZone({ uploader: acceptUpload });
+  useEffect4(() => {
+    if (pastedFiles.length > 0) {
+      acceptUpload(pastedFiles);
+    }
+  }, [pastedFiles, acceptUpload]);
+  const handleInsertMedia = useCallback5(
+    (items) => {
+      const from = getPos();
+      if (from === void 0) return;
+      const to = from + node.nodeSize;
+      insertMediaBlocks(editor, items, mediaType, className, { from, to });
+      handleModalClose();
+    },
+    [editor, mediaType, getPos, node, handleModalClose, className]
+  );
+  return /* @__PURE__ */ jsxs3(NodeViewWrapper4, { children: [
+    pastedFiles.length === 0 && /* @__PURE__ */ jsx5(DropZone, { onComplete: onDrop, children: /* @__PURE__ */ jsxs3("div", { className: "acms-admin-block-editor-image-drop", style: { width: "100%" }, children: [
+      /* @__PURE__ */ jsxs3("p", { className: "acms-admin-block-editor-image-drop-text", children: [
+        mediaType === "image" && /* @__PURE__ */ jsx5("span", { className: "acms-admin-block-editor-image-drop-text-main", children: "\u3053\u3053\u306B\u753B\u50CF\u3092\u30C9\u30E9\u30C3\u30B0" }),
+        mediaType === "file" && /* @__PURE__ */ jsx5("span", { className: "acms-admin-block-editor-image-drop-text-main", children: "\u3053\u3053\u306B\u30D5\u30A1\u30A4\u30EB\u3092\u30C9\u30E9\u30C3\u30B0" }),
+        /* @__PURE__ */ jsx5("span", { className: "acms-admin-block-editor-image-drop-text-sub", children: "\u307E\u305F\u306F" })
+      ] }),
+      /* @__PURE__ */ jsxs3("div", { className: "acms-admin-block-editor-button-group", children: [
+        /* @__PURE__ */ jsxs3(Button, { onClick: handleSelectClick, variant: "outlined", size: "default", type: "button", children: [
+          /* @__PURE__ */ jsx5(Icon, { name: "perm_media" }),
+          "\u30E1\u30C7\u30A3\u30A2\u9078\u629E"
+        ] }),
+        /* @__PURE__ */ jsxs3(Button, { onClick: handleUploadClick, variant: "filled", size: "default", type: "button", children: [
+          /* @__PURE__ */ jsx5(Icon, { name: "upload" }),
+          "\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx5(
+        "input",
+        {
+          id: "media-upload-input",
+          ref: fileInputRef,
+          type: "file",
+          multiple: true,
+          accept: mediaType === "image" ? "image/*" : void 0,
+          onChange: handleUploadFile,
+          style: { display: "none" }
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx5(
+      MediaInsert,
+      {
+        isOpen: isInsertModalOpen,
+        onInsert: handleInsertMedia,
+        files,
+        onClose: handleModalClose,
+        tab,
+        filetype: mediaType
+      }
+    )
+  ] });
+}
+
+// src/extensions/MediaUpload/MediaUpload.ts
+var imagePastePlugin = (editor) => new Plugin7({
+  props: {
+    handlePaste(view, event) {
+      const files = event.clipboardData?.files;
+      if (files && files.length > 0) {
+        const images = Array.from(files).filter((file) => file.type.startsWith("image/"));
+        if (images.length === 0) return false;
+        event.preventDefault();
+        editor.commands.uploadMediaImage(images);
+        return true;
+      }
+      return false;
+    }
+  }
+});
+var mediaDropPlugin = (editor) => new Plugin7({
+  props: {
+    handleDrop(view, event) {
+      const files = event.dataTransfer?.files;
+      if (!files || files.length === 0) {
+        return false;
+      }
+      const coordinates = view.posAtCoords({ left: event.clientX, top: event.clientY });
+      if (!coordinates) {
+        return false;
+      }
+      const $pos = view.state.doc.resolve(coordinates.pos);
+      for (let { depth } = $pos; depth > 0; depth -= 1) {
+        if ($pos.node(depth).type.name === "MediaUpload") {
+          return false;
+        }
+      }
+      event.preventDefault();
+      editor.chain().focus().setTextSelection(coordinates.pos).uploadMedia(Array.from(files)).run();
+      return true;
+    }
+  }
+});
+var MediaUpload = Node4.create({
+  name: "MediaUpload",
+  isolating: true,
+  defining: true,
+  group: "block",
+  draggable: false,
+  selectable: true,
+  inline: false,
+  addAttributes() {
+    return {
+      __pastedFiles: {
+        default: [],
+        parseHTML: () => [],
+        renderHTML: () => null
+      },
+      __mediaType: {
+        default: "image",
+        // 'image' or 'file'
+        parseHTML: (element) => element.getAttribute("data-media-type") || "image",
+        renderHTML: (attrs) => ({ "data-media-type": attrs.__mediaType })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+        getAttrs: () => ({})
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", { "data-type": this.name, ...HTMLAttributes }];
+  },
+  addCommands() {
+    return {
+      uploadMediaImage: (files) => ({ commands }) => commands.insertContent({
+        type: this.name,
+        attrs: {
+          __pastedFiles: files ?? [],
+          __mediaType: "image"
+        }
+      }),
+      uploadMediaFile: (files) => ({ commands }) => commands.insertContent({
+        type: this.name,
+        attrs: {
+          __pastedFiles: files ?? [],
+          __mediaType: "file"
+        }
+      }),
+      uploadMedia: (files) => ({ commands }) => commands.insertContent({
+        type: this.name,
+        attrs: {
+          __pastedFiles: files ?? [],
+          __mediaType: "all"
+        }
+      })
+    };
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer4(Dropzone);
+  },
+  addProseMirrorPlugins() {
+    return [imagePastePlugin(this.editor), mediaDropPlugin(this.editor)];
+  }
+});
+
+// src/extensions/CustomMark/CustomMark.ts
+import { Mark } from "@tiptap/core";
+var CustomMark = Mark.create({
+  name: "customMark",
+  // マークの名前
+  // 属性の定義
+  addAttributes() {
+    return {
+      class: {
+        default: null,
+        // デフォルトはnull
+        parseHTML: (element) => element.getAttribute("class"),
+        // HTMLからクラスを取得
+        renderHTML: (attributes) => {
+          if (!attributes.class) {
+            return {};
+          }
+          return {
+            class: attributes.class
+            // HTMLにクラスを追加
+          };
+        }
+      }
+    };
+  },
+  // HTMLのパース処理
+  parseHTML() {
+    return [
+      {
+        tag: "span.custom-mark"
+        // マークのHTMLタグを定義
+      }
+    ];
+  },
+  // HTMLのレンダリング処理
+  renderHTML({ HTMLAttributes }) {
+    return ["span", HTMLAttributes, 0];
+  }
+});
+
+// src/extensions/CustomConvertBlock/CustomConvertBlock.ts
+import { Extension as Extension6 } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+var collectParagraphTexts = (node, paragraphType) => {
+  const texts = [];
+  if (node.type === paragraphType) {
+    texts.push(node.textContent);
+  }
+  node.forEach((child) => {
+    texts.push(...collectParagraphTexts(child, paragraphType));
+  });
+  return texts;
+};
+var CustomConvertBlock = Extension6.create({
+  name: "CustomConvertBlock",
+  addCommands() {
+    return {
+      removeList: (pos) => ({ state, dispatch }) => {
+        const { doc, schema } = state;
+        const { bulletList, orderedList, paragraph, hardBreak } = schema.nodes;
+        const newParagraphs = [];
+        const listNode = doc.nodeAt(pos);
+        if (!listNode || listNode.type !== bulletList && listNode.type !== orderedList) {
+          return false;
+        }
+        listNode.forEach((listItemNode) => {
+          newParagraphs.push(...collectParagraphTexts(listItemNode, paragraph));
+        });
+        const textNodes = newParagraphs.flatMap((line, index, arr) => {
+          const nodes = [schema.text(line)];
+          if (index < arr.length - 1) {
+            nodes.push(hardBreak.create());
+          }
+          return nodes;
+        });
+        const paragraphNode = paragraph.create({}, textNodes);
+        const tr = state.tr.replaceWith(pos, pos + listNode.nodeSize, paragraphNode);
+        if (dispatch && tr.docChanged) {
+          dispatch(tr);
+          return true;
+        }
+        return false;
+      },
+      removeListAsParagraphs: (pos) => ({ state, dispatch }) => {
+        const { doc, schema } = state;
+        const { bulletList, orderedList, paragraph } = schema.nodes;
+        const listNode = doc.nodeAt(pos);
+        if (!listNode || listNode.type !== bulletList && listNode.type !== orderedList) {
+          return false;
+        }
+        const paragraphs = [];
+        listNode.forEach((listItemNode) => {
+          listItemNode.forEach((child) => {
+            if (child.type === paragraph) {
+              const text = child.textContent;
+              const lines = text.split(/\r?\n/);
+              lines.forEach((line) => {
+                paragraphs.push(paragraph.create({}, schema.text(line)));
+              });
+            } else {
+              paragraphs.push(child);
+            }
+          });
+        });
+        if (paragraphs.length === 0) {
+          return false;
+        }
+        const tr = state.tr.replaceWith(pos, pos + listNode.nodeSize, paragraphs);
+        if (dispatch && tr.docChanged) {
+          dispatch(tr);
+          return true;
+        }
+        return false;
+      },
+      unwrapList: () => ({ state, dispatch }) => {
+        const { selection, tr } = state;
+        const { $from } = selection;
+        let lifted = false;
+        for (let { depth } = $from; depth > 0; depth--) {
+          const node = $from.node(depth);
+          if (node.type.name === "listItem") {
+            const pos = $from.before(depth);
+            tr.setNodeMarkup(pos, state.schema.nodes.paragraph);
+            lifted = true;
+            break;
+          }
+        }
+        if (lifted && dispatch) {
+          dispatch(tr);
+          return true;
+        }
+        return false;
+      },
+      removeBlockquote: (pos) => ({ state, dispatch }) => {
+        const { doc, schema } = state;
+        const { blockquote } = schema.nodes;
+        const node = doc.nodeAt(pos);
+        if (!node || node.type !== blockquote) {
+          return false;
+        }
+        const { content } = node;
+        const tr = state.tr.replaceWith(pos, pos + node.nodeSize, content);
+        if (dispatch && tr.docChanged) {
+          dispatch(tr);
+          return true;
+        }
+        return false;
+      },
+      splitBulletList: (pos) => ({ state, dispatch }) => {
+        const { doc, schema } = state;
+        const { bulletList, listItem, paragraph, hardBreak } = schema.nodes;
+        const node = doc.nodeAt(pos);
+        if (!node || node.type !== paragraph) {
+          return false;
+        }
+        const items = [[]];
+        node.content.forEach((child) => {
+          if (child.type === hardBreak) {
+            items.push([]);
+          } else {
+            items[items.length - 1].push(child);
+          }
+        });
+        const listItems = items.filter((content) => content.length > 0).map((content) => listItem.create({}, paragraph.create({}, content)));
+        if (listItems.length === 0) {
+          return false;
+        }
+        const newList = bulletList.create({}, listItems);
+        const tr = state.tr.replaceWith(pos, pos + node.nodeSize, newList);
+        const selection = TextSelection.near(tr.doc.resolve(pos + 1));
+        if (dispatch && tr.docChanged) {
+          dispatch(tr.setSelection(selection));
+          return true;
+        }
+        return false;
+      },
+      splitOrderedList: (pos) => ({ state, dispatch }) => {
+        const { doc, schema } = state;
+        const { orderedList, listItem, paragraph, hardBreak } = schema.nodes;
+        const node = doc.nodeAt(pos);
+        if (!node || node.type !== paragraph) {
+          return false;
+        }
+        const items = [[]];
+        node.content.forEach((child) => {
+          if (child.type === hardBreak) {
+            items.push([]);
+          } else {
+            items[items.length - 1].push(child);
+          }
+        });
+        const listItems = items.filter((content) => content.length > 0).map((content) => listItem.create({}, paragraph.create({}, content)));
+        if (listItems.length === 0) {
+          return false;
+        }
+        const newList = orderedList.create({}, listItems);
+        const tr = state.tr.replaceWith(pos, pos + node.nodeSize, newList);
+        const selection = TextSelection.near(tr.doc.resolve(pos + 1));
+        if (dispatch && tr.docChanged) {
+          dispatch(tr.setSelection(selection));
+          return true;
+        }
+        return false;
+      }
+    };
+  }
+});
+
+// src/lib/utils/isCustomNodeSelected.ts
+var isTableGripSelected = (node) => {
+  let container = node;
+  while (container && !["TD", "TH"].includes(container.tagName)) {
+    container = container.parentElement;
+  }
+  const gripColumn = container && container.querySelector && container.querySelector("button.grip-column.selected");
+  const gripRow = container && container.querySelector && container.querySelector("button.grip-row.selected");
+  if (gripColumn || gripRow) {
+    return true;
+  }
+  return false;
+};
+var isCustomNodeSelected = (editor, node) => {
+  const customNodes = [
+    HorizontalRule.name,
+    ImageBlock.name,
+    MediaUpload.name,
+    CodeBlock.name,
+    ImageBlock.name,
+    FileBlock.name,
+    LinkButton.name,
+    // Link.name,
+    Figcaption.name
+  ];
+  return customNodes.some((type) => editor.isActive(type)) || isTableGripSelected(node);
+};
+
+// src/lib/utils/isTextSelected.ts
+import { isTextSelection } from "@tiptap/core";
+var isTextSelected = ({ editor }) => {
+  const {
+    state: {
+      doc,
+      selection,
+      selection: { empty, from, to }
+    }
+  } = editor;
+  const isEmptyTextBlock = !doc.textBetween(from, to).length && isTextSelection(selection);
+  if (empty || isEmptyTextBlock || !editor.isEditable) {
+    return false;
+  }
+  return true;
+};
+
+// src/lib/utils/index.ts
+function cn(...inputs) {
+  return classnames(...inputs);
+}
+
+export {
+  Selection,
+  Table,
+  isCellSelection,
+  TableCell,
+  TableRow,
+  TableHeader,
+  HorizontalRule,
+  Heading,
+  Document,
+  TrailingNode,
+  SlashCommand_default,
+  FontStyle,
+  Figcaption,
+  isAllowedBlockEditorLinkUri,
+  Link,
+  ImageBlock,
+  FileBlock,
+  PasteHandler,
+  LinkButton,
+  Column,
+  useMediaSelect,
+  MediaUpload,
+  CustomMark,
+  CustomConvertBlock,
+  StarterKit,
+  Highlight,
+  Underline,
+  TextAlign,
+  TextStyle,
+  Typography,
+  Subscript,
+  Superscript,
+  Placeholder,
+  Focus,
+  Dropcursor,
+  isCustomNodeSelected,
+  isTextSelected,
+  cn
+};
+//# sourceMappingURL=chunk-TKSGCO5Z.mjs.map