@bgx4k3p/huly-mcp-server 2.2.4 → 2.2.5

package/node_modules/prosemirror-menu/dist/index.d.ts

@@ -12,21 +12,24 @@ interface MenuElement {
     Render the element for display in the menu. Must return a DOM
     element and a function that can be used to update the element to
     a new state. The `update` function must return false if the
-    update hid the entire element.
+    update hid the entire element. May also return a `focusable`
+    DOM node, which is the node that should receive focus when this
+    element is focused. If not provided, the `dom` element will be used.
     */
     render(pm: EditorView): {
         dom: HTMLElement;
         update: (state: EditorState) => boolean;
+        focusable?: HTMLElement;
     };
 }
 /**
 An icon or label that, when clicked, executes a command.
 */
-declare class MenuItem implements MenuElement {
+declare class MenuItem<E extends HTMLElement = HTMLButtonElement> implements MenuElement {
     /**
     The spec used to create this item.
     */
-    readonly spec: MenuItemSpec;
+    readonly spec: MenuItemSpec<E>;
     /**
     Create a menu item.
     */
@@ -34,14 +37,14 @@ declare class MenuItem implements MenuElement {
     /**
     The spec used to create this item.
     */
-    spec: MenuItemSpec);
+    spec: MenuItemSpec<E>);
     /**
     Renders the icon according to its [display
     spec](https://prosemirror.net/docs/ref/#menu.MenuItemSpec.display), and adds an event handler which
     executes the command when the representation is clicked.
     */
     render(view: EditorView): {
-        dom: HTMLElement;
+        dom: HTMLButtonElement | E;
         update: (state: EditorState) => boolean;
     };
 }
@@ -68,7 +71,7 @@ type IconSpec = {
 /**
 The configuration object passed to the `MenuItem` constructor.
 */
-interface MenuItemSpec {
+interface MenuItemSpec<E extends HTMLElement = HTMLButtonElement> {
     /**
     The function to execute when the menu item is activated.
     */
@@ -94,7 +97,7 @@ interface MenuItemSpec {
     A function that renders the item. You must provide either this,
     [`icon`](https://prosemirror.net/docs/ref/#menu.MenuItemSpec.icon), or [`label`](https://prosemirror.net/docs/ref/#MenuItemSpec.label).
     */
-    render?: (view: EditorView) => HTMLElement;
+    render?: (view: EditorView) => E;
     /**
     Describes an icon to show for this item.
     */
@@ -124,6 +127,7 @@ A drop-down menu, displayed as a label with a downwards-pointing
 triangle to the right of it.
 */
 declare class Dropdown implements MenuElement {
+    private focusTimeout;
     /**
     Create a dropdown wrapping the elements.
     */
@@ -157,13 +161,16 @@ declare class Dropdown implements MenuElement {
     render(view: EditorView): {
         dom: HTMLElement;
         update: (state: EditorState) => boolean;
+        focusable: HTMLElement;
     };
+    setFocusIndex(index: number): void;
 }
 /**
 Represents a submenu wrapping a group of elements that start
 hidden and expand to the right when hovered over or tapped.
 */
 declare class DropdownSubmenu implements MenuElement {
+    private focusTimeout;
     /**
     Creates a submenu for the given group of menu elements. The
     following options are recognized:
@@ -184,7 +191,9 @@ declare class DropdownSubmenu implements MenuElement {
     render(view: EditorView): {
         dom: HTMLElement;
         update: (state: EditorState) => boolean;
+        focusable: HTMLElement;
     };
+    setFocusIndex(index: number): void;
 }
 /**
 Render the given, possibly nested, array of menu elements into a
@@ -195,6 +204,7 @@ be empty).
 declare function renderGrouped(view: EditorView, content: readonly (readonly MenuElement[])[]): {
     dom: DocumentFragment;
     update: (state: EditorState) => boolean;
+    focusables: HTMLElement[];
 };
 /**
 A set of basic editor-related icons. Contains the properties
@@ -209,23 +219,23 @@ declare const icons: {
 /**
 Menu item for the `joinUp` command.
 */
-declare const joinUpItem: MenuItem;
+declare const joinUpItem: MenuItem<HTMLButtonElement>;
 /**
 Menu item for the `lift` command.
 */
-declare const liftItem: MenuItem;
+declare const liftItem: MenuItem<HTMLButtonElement>;
 /**
 Menu item for the `selectParentNode` command.
 */
-declare const selectParentNodeItem: MenuItem;
+declare const selectParentNodeItem: MenuItem<HTMLButtonElement>;
 /**
 Menu item for the `undo` command.
 */
-declare let undoItem: MenuItem;
+declare let undoItem: MenuItem<HTMLButtonElement>;
 /**
 Menu item for the `redo` command.
 */
-declare let redoItem: MenuItem;
+declare let redoItem: MenuItem<HTMLButtonElement>;
 /**
 Build a menu item for wrapping the selection in a given node type.
 Adds `run` and `select` properties to the ones present in
@@ -234,7 +244,7 @@ attributes for the wrapping node.
 */
 declare function wrapItem(nodeType: NodeType, options: Partial<MenuItemSpec> & {
     attrs?: Attrs | null;
-}): MenuItem;
+}): MenuItem<HTMLButtonElement>;
 /**
 Build a menu item for changing the type of the textblock around the
 selection to the given type. Provides `run`, `active`, and `select`
@@ -243,7 +253,7 @@ be an object to provide the attributes for the textblock node.
 */
 declare function blockTypeItem(nodeType: NodeType, options: Partial<MenuItemSpec> & {
     attrs?: Attrs | null;
-}): MenuItem;
+}): MenuItem<HTMLButtonElement>;
 
 /**
 A plugin that will place a menu bar above the editor. Note that
@@ -256,6 +266,11 @@ declare function menuBar(options: {
     */
     content: readonly (readonly MenuElement[])[];
     /**
+    Determines whether the menu is placed before or after the editor in the DOM.
+    The default is "before".
+    */
+    position?: "before" | "after";
+    /**
     Determines whether the menu floats, i.e. whether it sticks to
     the top of the viewport when the editor is partially scrolled
     out of view.

package/node_modules/prosemirror-menu/dist/index.js

@@ -14,8 +14,9 @@ function hashPath(path) {
 }
 function getIcon(root, icon) {
     let doc = (root.nodeType == 9 ? root : root.ownerDocument) || document;
-    let node = doc.createElement("div");
+    let node = doc.createElement("button");
     node.className = prefix$2;
+    node.type = "button";
     if (icon.path) {
         let { path, width, height } = icon;
         let name = "pm-icon-" + hashPath(path).toString(16);
@@ -78,23 +79,28 @@ class MenuItem {
         let spec = this.spec;
         let dom = spec.render ? spec.render(view)
             : spec.icon ? getIcon(view.root, spec.icon)
-                : spec.label ? crel("div", null, translate(view, spec.label))
+                : spec.label ? crel("button", { type: "button" }, translate(view, spec.label))
                     : null;
         if (!dom)
             throw new RangeError("MenuItem without icon or label property");
         if (spec.title) {
-            const title = (typeof spec.title === "function" ? spec.title(view.state) : spec.title);
+            let title = (typeof spec.title === "function" ? spec.title(view.state) : spec.title);
             dom.setAttribute("title", translate(view, title));
         }
         if (spec.class)
             dom.classList.add(spec.class);
         if (spec.css)
             dom.style.cssText += spec.css;
-        dom.addEventListener("mousedown", e => {
-            e.preventDefault();
-            if (!dom.classList.contains(prefix$1 + "-disabled"))
+        dom.addEventListener("click", e => {
+            if (!dom.classList.contains(prefix$1 + "-disabled")) {
+                let setFocus = document.activeElement == dom || document.activeElement == view.dom;
                 spec.run(view.state, view.dispatch, view, e);
+                if (setFocus && document.activeElement == dom)
+                    view.focus();
+            }
         });
+        // Clicking on a menu item should not remove focus from the editor
+        dom.addEventListener("mousedown", e => e.preventDefault());
         function update(state) {
             if (spec.select) {
                 let selected = spec.select(state);
@@ -106,10 +112,12 @@ class MenuItem {
             if (spec.enable) {
                 enabled = spec.enable(state) || false;
                 setClass(dom, prefix$1 + "-disabled", !enabled);
+                dom.setAttribute("aria-disabled", (!enabled).toString());
             }
             if (spec.active) {
                 let active = enabled && spec.active(state) || false;
                 setClass(dom, prefix$1 + "-active", active);
+                dom.setAttribute("aria-pressed", active.toString());
             }
             return true;
         }
@@ -142,6 +150,15 @@ class Dropdown {
     */
     options = {}) {
         this.options = options;
+        /**
+        @internal
+        */
+        this.focusables = [];
+        /**
+        @internal
+        */
+        this.focusIndex = 0;
+        this.focusTimeout = -1;
         this.options = options || {};
         this.content = Array.isArray(content) ? content : [content];
     }
@@ -150,45 +167,76 @@ class Dropdown {
     */
     render(view) {
         let content = renderDropdownItems(this.content, view);
+        this.focusables = content.focusables;
         let win = view.dom.ownerDocument.defaultView || window;
-        let label = crel("div", { class: prefix$1 + "-dropdown " + (this.options.class || ""),
-            style: this.options.css }, translate(view, this.options.label || ""));
+        let btn = crel("button", {
+            type: "button",
+            class: prefix$1 + "-dropdown " + (this.options.class || ""),
+            style: this.options.css,
+            "aria-haspopup": "menu",
+            "aria-expanded": "false"
+        }, translate(view, this.options.label || ""));
         if (this.options.title)
-            label.setAttribute("title", translate(view, this.options.title));
-        let wrap = crel("div", { class: prefix$1 + "-dropdown-wrap" }, label);
+            btn.setAttribute("title", translate(view, this.options.title));
+        let wrap = crel("div", { class: prefix$1 + "-dropdown-wrap" }, btn);
         let open = null;
         let listeningOnClose = null;
         let close = () => {
             if (open && open.close()) {
                 open = null;
-                win.removeEventListener("mousedown", listeningOnClose);
+                win.removeEventListener("click", listeningOnClose);
             }
         };
-        label.addEventListener("mousedown", e => {
-            e.preventDefault();
+        btn.addEventListener("click", e => {
             markMenuEvent(e);
             if (open) {
                 close();
             }
             else {
-                open = this.expand(wrap, content.dom);
-                win.addEventListener("mousedown", listeningOnClose = () => {
+                open = this.expand(wrap, content.dom, btn);
+                win.addEventListener("click", listeningOnClose = () => {
                     if (!isMenuEvent(wrap))
                         close();
                 });
+                // If triggered using the keyboard, move focus to first item
+                if (e.detail === 0) {
+                    let focusIndex = findFocusableIndex(this.focusables, -1, 1);
+                    if (focusIndex != null)
+                        this.setFocusIndex(focusIndex);
+                }
+                open.node.addEventListener("keydown", (event) => {
+                    markMenuEvent(event);
+                    if (keyboardMoveFocus(this, event, "vertical")) ;
+                    else if (event.key === "Escape") {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        btn.focus();
+                        close();
+                    }
+                });
+                open.node.addEventListener("focusout", () => {
+                    clearTimeout(this.focusTimeout);
+                    this.focusTimeout = setTimeout(() => {
+                        let active = win.document.activeElement;
+                        if (active && open && !open.node.contains(active))
+                            close();
+                    }, 20);
+                });
             }
         });
+        // Clicking on a dropdown should not remove focus from the editor
+        btn.addEventListener("mousedown", e => e.preventDefault());
         function update(state) {
             let inner = content.update(state);
             wrap.style.display = inner ? "" : "none";
             return inner;
         }
-        return { dom: wrap, update };
+        return { dom: wrap, update, focusable: btn };
     }
     /**
     @internal
     */
-    expand(dom, items) {
+    expand(dom, items, trigger) {
         let menuDOM = crel("div", { class: prefix$1 + "-dropdown-menu " + (this.options.class || "") }, items);
         let done = false;
         function close() {
@@ -196,20 +244,72 @@ class Dropdown {
                 return false;
             done = true;
             dom.removeChild(menuDOM);
+            trigger.ariaControlsElements = [];
+            trigger.setAttribute("aria-expanded", "false");
             return true;
         }
         dom.appendChild(menuDOM);
+        trigger.ariaControlsElements = [items];
+        trigger.setAttribute("aria-expanded", "true");
         return { close, node: menuDOM };
     }
+    setFocusIndex(index) {
+        if (this.focusables.length <= 1)
+            return;
+        this.focusables[this.focusIndex].setAttribute("tabindex", "-1");
+        this.focusIndex = index;
+        let nextFocusItem = this.focusables[index];
+        nextFocusItem.setAttribute("tabindex", "0");
+        nextFocusItem.focus();
+    }
+}
+function findFocusableIndex(focusables, startIndex, delta) {
+    let length = focusables.length;
+    for (let i = 0, index = startIndex + delta;; index += delta, i++) {
+        let normIndex = (index + length) % length;
+        if (focusables[normIndex].style.display != "none")
+            return normIndex;
+        if (i == length)
+            return null;
+    }
+}
+function keyboardMoveFocus(control, event, orientation) {
+    let { focusables, focusIndex } = control;
+    let move = event.key == (orientation == "vertical" ? "ArrowDown" : "ArrowRight") ? findFocusableIndex(focusables, focusIndex, 1) :
+        event.key == (orientation == "vertical" ? "ArrowUp" : "ArrowLeft") ? findFocusableIndex(focusables, focusIndex, -1) :
+            event.key == "Home" ? findFocusableIndex(focusables, -1, 1) :
+                event.key == "End" ? findFocusableIndex(focusables, focusables.length, -1) : null;
+    if (move == null)
+        return false;
+    event.preventDefault();
+    event.stopPropagation();
+    control.setFocusIndex(move);
+    return true;
 }
 function renderDropdownItems(items, view) {
-    let rendered = [], updates = [];
+    let elts = [], focusables = [], updates = [];
     for (let i = 0; i < items.length; i++) {
-        let { dom, update } = items[i].render(view);
-        rendered.push(crel("div", { class: prefix$1 + "-dropdown-item" }, dom));
+        let item = items[i];
+        let { dom, update, focusable } = item.render(view);
+        elts.push(crel("li", {
+            class: `${prefix$1}-dropdown-item`,
+            role: "menuitem",
+            "tabindex": "-1"
+        }, dom));
+        focusables.push(focusable || dom);
         updates.push(update);
     }
-    return { dom: rendered, update: combineUpdates(updates, rendered) };
+    function update(state) {
+        let something = false;
+        for (let i = 0; i < elts.length; i++) {
+            let dom = elts[i], up = updates[i](state);
+            if (up)
+                something = true;
+            dom.style.display = up ? "" : "none";
+        }
+        return something;
+    }
+    return { dom: crel("ul", { role: "menu" }, elts), update, focusables };
 }
 function combineUpdates(updates, nodes) {
     return (state) => {
@@ -238,6 +338,15 @@ class DropdownSubmenu {
     */
     options = {}) {
         this.options = options;
+        /**
+        @internal
+        */
+        this.focusables = [];
+        /**
+        @internal
+        */
+        this.focusIndex = 0;
+        this.focusTimeout = -1;
         this.content = Array.isArray(content) ? content : [content];
     }
     /**
@@ -245,29 +354,70 @@ class DropdownSubmenu {
     */
     render(view) {
         let items = renderDropdownItems(this.content, view);
+        this.focusables = items.focusables;
         let win = view.dom.ownerDocument.defaultView || window;
-        let label = crel("div", { class: prefix$1 + "-submenu-label" }, translate(view, this.options.label || ""));
-        let wrap = crel("div", { class: prefix$1 + "-submenu-wrap" }, label, crel("div", { class: prefix$1 + "-submenu" }, items.dom));
+        let btn = crel("button", { type: "button", class: prefix$1 + "-submenu-label" }, translate(view, this.options.label || ""));
+        let wrap = crel("div", { class: prefix$1 + "-submenu-wrap" }, btn, crel("div", { class: prefix$1 + "-submenu" }, items.dom));
         let listeningOnClose = null;
-        label.addEventListener("mousedown", e => {
+        let openSubmenu = (e) => {
             e.preventDefault();
+            e.stopPropagation();
             markMenuEvent(e);
-            setClass(wrap, prefix$1 + "-submenu-wrap-active", false);
+            setClass(wrap, prefix$1 + "-submenu-wrap-active", true);
             if (!listeningOnClose)
-                win.addEventListener("mousedown", listeningOnClose = () => {
+                win.addEventListener("click", listeningOnClose = () => {
                     if (!isMenuEvent(wrap)) {
                         wrap.classList.remove(prefix$1 + "-submenu-wrap-active");
-                        win.removeEventListener("mousedown", listeningOnClose);
+                        win.removeEventListener("click", listeningOnClose);
                         listeningOnClose = null;
                     }
                 });
+            if (!(e.type == "click" && e.detail)) {
+                let focusIndex = findFocusableIndex(this.focusables, -1, 1);
+                if (focusIndex != null)
+                    this.setFocusIndex(focusIndex);
+            }
+        };
+        btn.addEventListener("click", openSubmenu);
+        btn.addEventListener("keydown", e => {
+            if (e.key === "ArrowRight")
+                openSubmenu(e);
+        });
+        // Clicking on an item should not remove focus from the editor
+        btn.addEventListener("mousedown", e => e.preventDefault());
+        items.dom.addEventListener("keydown", (event) => {
+            markMenuEvent(event);
+            if (keyboardMoveFocus(this, event, "vertical")) ;
+            else if (event.key === "Escape" || event.key === "ArrowLeft") {
+                event.preventDefault();
+                event.stopPropagation();
+                setClass(wrap, prefix$1 + "-submenu-wrap-active", false);
+                btn.focus();
+            }
+        });
+        items.dom.addEventListener("focusout", () => {
+            clearTimeout(this.focusTimeout);
+            this.focusTimeout = setTimeout(() => {
+                let active = win.document.activeElement;
+                if (active && !items.dom.contains(active))
+                    wrap.classList.remove(prefix$1 + "-submenu-wrap-active");
+            }, 20);
         });
         function update(state) {
             let inner = items.update(state);
             wrap.style.display = inner ? "" : "none";
             return inner;
         }
-        return { dom: wrap, update };
+        return { dom: wrap, update, focusable: btn };
+    }
+    setFocusIndex(index) {
+        if (this.focusables.length <= 1)
+            return;
+        this.focusables[this.focusIndex].setAttribute("tabindex", "-1");
+        this.focusIndex = index;
+        let nextFocusItem = this.focusables[index];
+        nextFocusItem.setAttribute("tabindex", "0");
+        nextFocusItem.focus();
     }
 }
 /**
@@ -278,11 +428,12 @@ be empty).
 */
 function renderGrouped(view, content) {
     let result = document.createDocumentFragment();
-    let updates = [], separators = [];
+    let updates = [], focusables = [], separators = [];
     for (let i = 0; i < content.length; i++) {
         let items = content[i], localUpdates = [], localNodes = [];
         for (let j = 0; j < items.length; j++) {
-            let { dom, update } = items[j].render(view);
+            let { dom, update, focusable } = items[j].render(view);
+            focusables.push(focusable || dom);
             let span = crel("span", { class: prefix$1 + "item" }, dom);
             result.appendChild(span);
             localNodes.push(span);
@@ -306,10 +457,10 @@ function renderGrouped(view, content) {
         }
         return something;
     }
-    return { dom: result, update };
+    return { dom: result, update, focusables };
 }
 function separator() {
-    return crel("span", { class: prefix$1 + "separator" });
+    return crel("span", { class: prefix$1 + "separator", role: "separator" });
 }
 /**
 A set of basic editor-related icons. Contains the properties
@@ -479,6 +630,8 @@ class MenuBarView {
     constructor(editorView, options) {
         this.editorView = editorView;
         this.options = options;
+        this.focusables = [];
+        this.focusIndex = 0;
         this.spacer = null;
         this.maxHeight = 0;
         this.widthForMaxHeight = 0;
@@ -486,15 +639,21 @@ class MenuBarView {
         this.scrollHandler = null;
         this.root = editorView.root;
         this.wrapper = crel("div", { class: prefix + "-wrapper" });
-        this.menu = this.wrapper.appendChild(crel("div", { class: prefix }));
+        this.menu = this.wrapper.appendChild(crel("div", { class: prefix, role: "toolbar" }));
         this.menu.className = prefix;
+        this.menu.ariaControlsElements = [editorView.dom];
         if (editorView.dom.parentNode)
             editorView.dom.parentNode.replaceChild(this.wrapper, editorView.dom);
-        this.wrapper.appendChild(editorView.dom);
-        let { dom, update } = renderGrouped(this.editorView, this.options.content);
+        if (options.position === "after") {
+            this.wrapper.insertBefore(editorView.dom, this.wrapper.firstChild);
+        }
+        else {
+            this.wrapper.appendChild(editorView.dom);
+        }
+        let { dom, update, focusables } = renderGrouped(this.editorView, this.options.content);
         this.contentUpdate = update;
+        this.focusables = focusables;
         this.menu.appendChild(dom);
-        this.update();
         if (options.floating && !isIOS()) {
             this.updateFloat();
             let potentialScrollers = getAllWrapping(this.wrapper);
@@ -507,6 +666,34 @@ class MenuBarView {
             };
             potentialScrollers.forEach(el => el.addEventListener('scroll', this.scrollHandler));
         }
+        // update focusIndex on focus change
+        for (let i = 0; i < focusables.length; i++) {
+            let focusable = focusables[i];
+            // set `tabindex` to -1 for all but the first focusable item
+            if (i)
+                focusable.setAttribute("tabindex", "-1");
+            focusable.addEventListener("focus", () => {
+                if (this.focusIndex === i)
+                    return;
+                let prevFocusItem = this.focusables[this.focusIndex];
+                prevFocusItem.setAttribute("tabindex", "-1");
+                focusable.setAttribute("tabindex", "0");
+                this.focusIndex = i;
+            });
+        }
+        this.menu.addEventListener("keydown", (event) => {
+            keyboardMoveFocus(this, event, "horizontal");
+        });
+        this.update();
+    }
+    setFocusIndex(index) {
+        if (this.focusables.length <= 1)
+            return;
+        this.focusables[this.focusIndex].setAttribute("tabindex", "-1");
+        this.focusIndex = index;
+        let nextFocusItem = this.focusables[index];
+        nextFocusItem.setAttribute("tabindex", "0");
+        nextFocusItem.focus();
     }
     update() {
         if (this.editorView.root != this.root) {
@@ -515,7 +702,13 @@ class MenuBarView {
             this.menu.replaceChild(dom, this.menu.firstChild);
             this.root = this.editorView.root;
         }
+        let active = this.editorView.dom.ownerDocument.activeElement == this.focusables[this.focusIndex];
         this.contentUpdate(this.editorView.state);
+        if (active && this.focusables[this.focusIndex].style.display == "none") {
+            let next = findFocusableIndex(this.focusables, this.focusIndex, 1);
+            if (next != null)
+                this.setFocusIndex(next);
+        }
         if (this.floating) {
             this.updateScrollCursor();
         }

package/node_modules/prosemirror-menu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-menu",
-  "version": "1.2.5",
+  "version": "1.3.2",
   "description": "Simple menu elements for ProseMirror",
   "type": "module",
   "main": "dist/index.cjs",
@@ -25,7 +25,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/prosemirror/prosemirror-menu.git"
+    "url": "git+https://code.haverbeke.berlin/prosemirror/prosemirror-menu.git"
   },
   "dependencies": {
     "crelt": "^1.0.0",

package/node_modules/prosemirror-menu/src/README.md

@@ -1,8 +1,37 @@
+# prosemirror-menu
+
+[ [**WEBSITE**](https://prosemirror.net) | [**ISSUES**](https://code.haverbeke.berlin/prosemirror/prosemirror-menu/issues) | [**FORUM**](https://discuss.prosemirror.net) | [**GITTER**](https://gitter.im/ProseMirror/prosemirror) ]
+
+This is a non-core example module for [ProseMirror](https://prosemirror.net).
+ProseMirror is a well-behaved rich semantic content editor based on
+contentEditable, with support for collaborative editing and custom
+document schemas.
+
+This module defines an abstraction for building a menu for the
+ProseMirror editor, along with an implementation of a menubar.
+
+**Note** that this module exists mostly as an example of how you
+_might_ want to approach adding a menu to ProseMirror, but is not
+maintained as actively as the core modules related to actual editing.
+If you want to extend or improve it, the recommended way is to fork
+it. If you are interested in maintaining a serious menu component for
+ProseMirror, publish your fork, and if it works for me, I'll gladly
+deprecate this in favor of your module.
+
+This code is released under an
+[MIT license](https://code.haverbeke.berlin/prosemirror/prosemirror/src/branch/main/LICENSE).
+There's a [forum](http://discuss.prosemirror.net) for general
+discussion and support requests, and the
+[bug tracker](https://code.haverbeke.berlin/prosemirror/prosemirror-menu/issues)
+is the place to report issues.
+
+## Documentation
+
 This module defines a number of building blocks for ProseMirror menus,
 along with a [menu bar](#menu.menuBar) implementation.
 
 When using this module, you should make sure its
-[`style/menu.css`](https://github.com/ProseMirror/prosemirror-menu/blob/master/style/menu.css)
+[`style/menu.css`](https://code.haverbeke.berlin/prosemirror/prosemirror-menu/src/branch/main/style/menu.css)
 file is loaded into your page.
 
 @MenuElement

package/node_modules/prosemirror-menu/src/icons.ts

@@ -13,10 +13,11 @@ function hashPath(path: string) {
 export function getIcon(
   root: Document | ShadowRoot,
   icon: {path: string, width: number, height: number} | {text: string, css?: string} | {dom: Node}
-): HTMLElement {
+): HTMLButtonElement {
   let doc = (root.nodeType == 9 ? root as Document : root.ownerDocument) || document
-  let node = doc.createElement("div")
+  let node = doc.createElement("button")
   node.className = prefix
+  node.type = "button"
   if ((icon as any).path) {
     let {path, width, height} = icon as {path: string, width: number, height: number}
     let name = "pm-icon-" + hashPath(path).toString(16)