primevue 3.26.1 → 3.28.0

package/panelmenu/panelmenu.cjs.js

@@ -1,15 +1,22 @@
 'use strict';
 
+var BaseComponent = require('primevue/basecomponent');
+var ChevronDownIcon = require('primevue/icons/chevrondown');
+var ChevronRightIcon = require('primevue/icons/chevronright');
 var utils = require('primevue/utils');
 var Ripple = require('primevue/ripple');
 var vue = require('vue');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent);
+var ChevronDownIcon__default = /*#__PURE__*/_interopDefaultLegacy(ChevronDownIcon);
+var ChevronRightIcon__default = /*#__PURE__*/_interopDefaultLegacy(ChevronRightIcon);
 var Ripple__default = /*#__PURE__*/_interopDefaultLegacy(Ripple);
 
 var script$2 = {
     name: 'PanelMenuSub',
+    extends: BaseComponent__default["default"],
     emits: ['item-toggle'],
     props: {
         panelId: {
@@ -28,8 +35,8 @@ var script$2 = {
             type: Number,
             default: 0
         },
-        template: {
-            type: Function,
+        templates: {
+            type: Object,
             default: null
         },
         activeItemPath: {
@@ -54,6 +61,14 @@ var script$2 = {
         getItemLabel(processedItem) {
             return this.getItemProp(processedItem, 'label');
         },
+        getPTOptions(processedItem, key) {
+            return this.ptm(key, {
+                context: {
+                    active: this.isItemActive(processedItem),
+                    focused: this.isItemFocused(processedItem)
+                }
+            });
+        },
         isItemActive(processedItem) {
             return this.activeItemPath.some((path) => path.key === processedItem.key);
         },
@@ -107,55 +122,52 @@ var script$2 = {
         getItemIconClass(processedItem) {
             return ['p-menuitem-icon', this.getItemProp(processedItem, 'icon')];
         },
-        getItemToggleIconClass(processedItem) {
-            return ['p-submenu-icon', this.isItemActive(processedItem) ? 'pi pi-fw pi-chevron-down' : 'pi pi-fw pi-chevron-right'];
-        },
         getSeparatorItemClass(processedItem) {
             return ['p-menuitem-separator', this.getItemProp(processedItem, 'class')];
         }
     },
+    components: {
+        ChevronRightIcon: ChevronRightIcon__default["default"],
+        ChevronDownIcon: ChevronDownIcon__default["default"]
+    },
     directives: {
         ripple: Ripple__default["default"]
     }
 };
 
-const _hoisted_1$1 = { class: "p-submenu-list" };
-const _hoisted_2$1 = ["id", "aria-label", "aria-expanded", "aria-level", "aria-setsize", "aria-posinset"];
-const _hoisted_3$1 = ["onClick"];
-const _hoisted_4$1 = ["href", "onClick"];
-const _hoisted_5$1 = { class: "p-menuitem-text" };
-const _hoisted_6$1 = ["href", "target"];
-const _hoisted_7$1 = { class: "p-menuitem-text" };
-const _hoisted_8$1 = { class: "p-toggleable-content" };
+const _hoisted_1$1 = ["id", "aria-label", "aria-expanded", "aria-level", "aria-setsize", "aria-posinset"];
+const _hoisted_2$1 = ["onClick"];
+const _hoisted_3$1 = ["href", "onClick"];
+const _hoisted_4$1 = ["href", "target"];
 
 function render$2(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_router_link = vue.resolveComponent("router-link");
   const _component_PanelMenuSub = vue.resolveComponent("PanelMenuSub", true);
   const _directive_ripple = vue.resolveDirective("ripple");
 
-  return (vue.openBlock(), vue.createElementBlock("ul", _hoisted_1$1, [
+  return (vue.openBlock(), vue.createElementBlock("ul", vue.mergeProps({ class: "p-submenu-list" }, _ctx.ptm('menu')), [
     (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.items, (processedItem, index) => {
       return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
         key: $options.getItemKey(processedItem)
       }, [
         ($options.isItemVisible(processedItem) && !$options.getItemProp(processedItem, 'separator'))
-          ? (vue.openBlock(), vue.createElementBlock("li", {
+          ? (vue.openBlock(), vue.createElementBlock("li", vue.mergeProps({
               key: 0,
               id: $options.getItemId(processedItem),
-              style: vue.normalizeStyle($options.getItemProp(processedItem, 'style')),
-              class: vue.normalizeClass($options.getItemClass(processedItem)),
+              style: $options.getItemProp(processedItem, 'style'),
+              class: $options.getItemClass(processedItem),
               role: "treeitem",
               "aria-label": $options.getItemLabel(processedItem),
               "aria-expanded": $options.isItemGroup(processedItem) ? $options.isItemActive(processedItem) : undefined,
               "aria-level": $props.level + 1,
               "aria-setsize": $options.getAriaSetSize(),
               "aria-posinset": $options.getAriaPosInset(index)
-            }, [
-              vue.createElementVNode("div", {
+            }, $options.getPTOptions(processedItem, 'menuitem')), [
+              vue.createElementVNode("div", vue.mergeProps({
                 class: "p-menuitem-content",
                 onClick: $event => ($options.onItemClick($event, processedItem))
-              }, [
-                (!$props.template)
+              }, $options.getPTOptions(processedItem, 'content')), [
+                (!$props.templates.item)
                   ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                       ($options.getItemProp(processedItem, 'to') && !$options.isItemDisabled(processedItem))
                         ? (vue.openBlock(), vue.createBlock(_component_router_link, {
@@ -164,59 +176,79 @@ function render$2(_ctx, _cache, $props, $setup, $data, $options) {
                             custom: ""
                           }, {
                             default: vue.withCtx(({ navigate, href, isActive, isExactActive }) => [
-                              vue.withDirectives((vue.openBlock(), vue.createElementBlock("a", {
+                              vue.withDirectives((vue.openBlock(), vue.createElementBlock("a", vue.mergeProps({
                                 href: href,
-                                class: vue.normalizeClass($options.getItemActionClass(processedItem, { isActive, isExactActive })),
+                                class: $options.getItemActionClass(processedItem, { isActive, isExactActive }),
                                 tabindex: "-1",
                                 "aria-hidden": "true",
                                 onClick: $event => ($options.onItemActionClick($event, navigate))
-                              }, [
-                                ($options.getItemProp(processedItem, 'icon'))
-                                  ? (vue.openBlock(), vue.createElementBlock("span", {
+                              }, $options.getPTOptions(processedItem, 'action')), [
+                                ($props.templates.itemicon)
+                                  ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.templates.itemicon), {
                                       key: 0,
+                                      item: processedItem.item,
                                       class: vue.normalizeClass($options.getItemIconClass(processedItem))
-                                    }, null, 2))
-                                  : vue.createCommentVNode("", true),
-                                vue.createElementVNode("span", _hoisted_5$1, vue.toDisplayString($options.getItemLabel(processedItem)), 1)
-                              ], 10, _hoisted_4$1)), [
+                                    }, null, 8, ["item", "class"]))
+                                  : ($options.getItemProp(processedItem, 'icon'))
+                                    ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+                                        key: 1,
+                                        class: $options.getItemIconClass(processedItem)
+                                      }, $options.getPTOptions(processedItem, 'icon')), null, 16))
+                                    : vue.createCommentVNode("", true),
+                                vue.createElementVNode("span", vue.mergeProps({ class: "p-menuitem-text" }, $options.getPTOptions(processedItem, 'label')), vue.toDisplayString($options.getItemLabel(processedItem)), 17)
+                              ], 16, _hoisted_3$1)), [
                                 [_directive_ripple]
                               ])
                             ]),
                             _: 2
                           }, 1032, ["to"]))
-                        : vue.withDirectives((vue.openBlock(), vue.createElementBlock("a", {
+                        : vue.withDirectives((vue.openBlock(), vue.createElementBlock("a", vue.mergeProps({
                             key: 1,
                             href: $options.getItemProp(processedItem, 'url'),
-                            class: vue.normalizeClass($options.getItemActionClass(processedItem)),
+                            class: $options.getItemActionClass(processedItem),
                             target: $options.getItemProp(processedItem, 'target'),
                             tabindex: "-1",
                             "aria-hidden": "true"
-                          }, [
+                          }, $options.getPTOptions(processedItem, 'action')), [
                             ($options.isItemGroup(processedItem))
-                              ? (vue.openBlock(), vue.createElementBlock("span", {
-                                  key: 0,
-                                  class: vue.normalizeClass($options.getItemToggleIconClass(processedItem))
-                                }, null, 2))
+                              ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                                  ($props.templates.submenuicon)
+                                    ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.templates.submenuicon), vue.mergeProps({
+                                        key: 0,
+                                        class: "p-submenu-icon",
+                                        active: $options.isItemActive(processedItem)
+                                      }, $options.getPTOptions(processedItem, 'submenuIcon')), null, 16, ["active"]))
+                                    : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($options.isItemActive(processedItem) ? 'ChevronDownIcon' : 'ChevronRightIcon'), vue.mergeProps({
+                                        key: 1,
+                                        class: "p-submenu-icon"
+                                      }, $options.getPTOptions(processedItem, 'submenuIcon')), null, 16))
+                                ], 64))
                               : vue.createCommentVNode("", true),
-                            ($options.getItemProp(processedItem, 'icon'))
-                              ? (vue.openBlock(), vue.createElementBlock("span", {
+                            ($props.templates.itemicon)
+                              ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.templates.itemicon), {
                                   key: 1,
+                                  item: processedItem.item,
                                   class: vue.normalizeClass($options.getItemIconClass(processedItem))
-                                }, null, 2))
-                              : vue.createCommentVNode("", true),
-                            vue.createElementVNode("span", _hoisted_7$1, vue.toDisplayString($options.getItemLabel(processedItem)), 1)
-                          ], 10, _hoisted_6$1)), [
+                                }, null, 8, ["item", "class"]))
+                              : ($options.getItemProp(processedItem, 'icon'))
+                                ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+                                    key: 2,
+                                    class: $options.getItemIconClass(processedItem)
+                                  }, $options.getPTOptions(processedItem, 'icon')), null, 16))
+                                : vue.createCommentVNode("", true),
+                            vue.createElementVNode("span", vue.mergeProps({ class: "p-menuitem-text" }, $options.getPTOptions(processedItem, 'label')), vue.toDisplayString($options.getItemLabel(processedItem)), 17)
+                          ], 16, _hoisted_4$1)), [
                             [_directive_ripple]
                           ])
                     ], 64))
-                  : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.template), {
+                  : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.templates.item), {
                       key: 1,
                       item: processedItem.item
                     }, null, 8, ["item"]))
-              ], 8, _hoisted_3$1),
+              ], 16, _hoisted_2$1),
               vue.createVNode(vue.Transition, { name: "p-toggleable-content" }, {
                 default: vue.withCtx(() => [
-                  vue.withDirectives(vue.createElementVNode("div", _hoisted_8$1, [
+                  vue.withDirectives(vue.createElementVNode("div", vue.mergeProps({ class: "p-toggleable-content" }, _ctx.ptm('toggleableContent')), [
                     ($options.isItemVisible(processedItem) && $options.isItemGroup(processedItem))
                       ? (vue.openBlock(), vue.createBlock(_component_PanelMenuSub, {
                           key: 0,
@@ -226,37 +258,39 @@ function render$2(_ctx, _cache, $props, $setup, $data, $options) {
                           focusedItemId: $props.focusedItemId,
                           items: processedItem.items,
                           level: $props.level + 1,
-                          template: $props.template,
+                          templates: $props.templates,
                           activeItemPath: $props.activeItemPath,
                           exact: $props.exact,
-                          onItemToggle: $options.onItemToggle
-                        }, null, 8, ["id", "panelId", "focusedItemId", "items", "level", "template", "activeItemPath", "exact", "onItemToggle"]))
+                          onItemToggle: $options.onItemToggle,
+                          pt: _ctx.pt
+                        }, null, 8, ["id", "panelId", "focusedItemId", "items", "level", "templates", "activeItemPath", "exact", "onItemToggle", "pt"]))
                       : vue.createCommentVNode("", true)
-                  ], 512), [
+                  ], 16), [
                     [vue.vShow, $options.isItemActive(processedItem)]
                   ])
                 ]),
                 _: 2
               }, 1024)
-            ], 14, _hoisted_2$1))
+            ], 16, _hoisted_1$1))
           : vue.createCommentVNode("", true),
         ($options.isItemVisible(processedItem) && $options.getItemProp(processedItem, 'separator'))
-          ? (vue.openBlock(), vue.createElementBlock("li", {
+          ? (vue.openBlock(), vue.createElementBlock("li", vue.mergeProps({
               key: 1,
-              style: vue.normalizeStyle($options.getItemProp(processedItem, 'style')),
-              class: vue.normalizeClass($options.getSeparatorItemClass(processedItem)),
+              style: $options.getItemProp(processedItem, 'style'),
+              class: $options.getSeparatorItemClass(processedItem),
               role: "separator"
-            }, null, 6))
+            }, _ctx.ptm('separator')), null, 16))
           : vue.createCommentVNode("", true)
       ], 64))
     }), 128))
-  ]))
+  ], 16))
 }
 
 script$2.render = render$2;
 
 var script$1 = {
     name: 'PanelMenuList',
+    extends: BaseComponent__default["default"],
     emits: ['item-toggle', 'header-focus'],
     props: {
         panelId: {
@@ -267,8 +301,8 @@ var script$1 = {
             type: Array,
             default: null
         },
-        template: {
-            type: Function,
+        templates: {
+            type: Object,
             default: null
         },
         expandedKeys: {
@@ -634,20 +668,22 @@ function render$1(_ctx, _cache, $props, $setup, $data, $options) {
     panelId: $props.panelId,
     focusedItemId: $data.focused ? $options.focusedItemId : undefined,
     items: $options.processedItems,
-    template: $props.template,
+    templates: $props.templates,
     activeItemPath: $data.activeItemPath,
     exact: $props.exact,
     onFocus: $options.onFocus,
     onBlur: $options.onBlur,
     onKeydown: $options.onKeyDown,
-    onItemToggle: $options.onItemToggle
-  }, null, 8, ["id", "aria-activedescendant", "panelId", "focusedItemId", "items", "template", "activeItemPath", "exact", "onFocus", "onBlur", "onKeydown", "onItemToggle"]))
+    onItemToggle: $options.onItemToggle,
+    pt: _ctx.pt
+  }, null, 8, ["id", "aria-activedescendant", "panelId", "focusedItemId", "items", "templates", "activeItemPath", "exact", "onFocus", "onBlur", "onKeydown", "onItemToggle", "pt"]))
 }
 
 script$1.render = render$1;
 
 var script = {
     name: 'PanelMenu',
+    extends: BaseComponent__default["default"],
     emits: ['update:expandedKeys', 'panel-open', 'panel-close'],
     props: {
         model: {
@@ -688,6 +724,14 @@ var script = {
         getItemLabel(item) {
             return this.getItemProp(item, 'label');
         },
+        getPTOptions(item, key) {
+            return this.ptm(key, {
+                options: {
+                    active: this.isItemActive(item),
+                    focused: this.isItemFocused(item)
+                }
+            });
+        },
         isItemActive(item) {
             return this.expandedKeys ? this.expandedKeys[this.getItemProp(item, 'key')] : utils.ObjectUtils.equals(item, this.activeItem);
         },
@@ -697,6 +741,9 @@ var script = {
         isItemDisabled(item) {
             return this.getItemProp(item, 'disabled');
         },
+        isItemFocused(item) {
+            return utils.ObjectUtils.equals(item, this.activeItem);
+        },
         getPanelId(index) {
             return `${this.id}_${index}`;
         },
@@ -849,50 +896,42 @@ var script = {
         },
         getHeaderIconClass(item) {
             return ['p-menuitem-icon', this.getItemProp(item, 'icon')];
-        },
-        getHeaderToggleIconClass(item) {
-            return ['p-submenu-icon', this.isItemActive(item) ? 'pi pi-chevron-down' : 'pi pi-chevron-right'];
         }
     },
     components: {
-        PanelMenuList: script$1
+        PanelMenuList: script$1,
+        ChevronRightIcon: ChevronRightIcon__default["default"],
+        ChevronDownIcon: ChevronDownIcon__default["default"]
     }
 };
 
 const _hoisted_1 = ["id"];
 const _hoisted_2 = ["id", "tabindex", "aria-label", "aria-expanded", "aria-controls", "aria-disabled", "onClick", "onKeydown"];
-const _hoisted_3 = { class: "p-panelmenu-header-content" };
-const _hoisted_4 = ["href", "onClick"];
-const _hoisted_5 = { class: "p-menuitem-text" };
-const _hoisted_6 = ["href"];
-const _hoisted_7 = { class: "p-menuitem-text" };
-const _hoisted_8 = ["id", "aria-labelledby"];
-const _hoisted_9 = {
-  key: 0,
-  class: "p-panelmenu-content"
-};
+const _hoisted_3 = ["href", "onClick"];
+const _hoisted_4 = ["href"];
+const _hoisted_5 = ["id", "aria-labelledby"];
 
 function render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_router_link = vue.resolveComponent("router-link");
   const _component_PanelMenuList = vue.resolveComponent("PanelMenuList");
 
-  return (vue.openBlock(), vue.createElementBlock("div", {
+  return (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
     id: $data.id,
     class: "p-panelmenu p-component"
-  }, [
+  }, _ctx.ptm('root')), [
     (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.model, (item, index) => {
       return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
         key: $options.getPanelKey(index)
       }, [
         ($options.isItemVisible(item))
-          ? (vue.openBlock(), vue.createElementBlock("div", {
+          ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
               key: 0,
-              style: vue.normalizeStyle($options.getItemProp(item, 'style')),
-              class: vue.normalizeClass($options.getPanelClass(item))
-            }, [
-              vue.createElementVNode("div", {
+              style: $options.getItemProp(item, 'style'),
+              class: $options.getPanelClass(item)
+            }, _ctx.ptm('panel')), [
+              vue.createElementVNode("div", vue.mergeProps({
                 id: $options.getHeaderId(index),
-                class: vue.normalizeClass($options.getHeaderClass(item)),
+                class: $options.getHeaderClass(item),
                 tabindex: $options.isItemDisabled(item) ? -1 : $props.tabindex,
                 role: "button",
                 "aria-label": $options.getItemLabel(item),
@@ -901,8 +940,8 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
                 "aria-disabled": $options.isItemDisabled(item),
                 onClick: $event => ($options.onHeaderClick($event, item)),
                 onKeydown: $event => ($options.onHeaderKeyDown($event, item))
-              }, [
-                vue.createElementVNode("div", _hoisted_3, [
+              }, $options.getPTOptions(item, 'header')), [
+                vue.createElementVNode("div", vue.mergeProps({ class: "p-panelmenu-header-content" }, $options.getPTOptions(item, 'headerContent')), [
                   (!_ctx.$slots.item)
                     ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                         ($options.getItemProp(item, 'to') && !$options.isItemDisabled(item))
@@ -912,82 +951,100 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
                               custom: ""
                             }, {
                               default: vue.withCtx(({ navigate, href, isActive, isExactActive }) => [
-                                vue.createElementVNode("a", {
+                                vue.createElementVNode("a", vue.mergeProps({
                                   href: href,
-                                  class: vue.normalizeClass($options.getHeaderActionClass(item, { isActive, isExactActive })),
+                                  class: $options.getHeaderActionClass(item, { isActive, isExactActive }),
                                   tabindex: -1,
                                   onClick: $event => ($options.onHeaderActionClick($event, navigate))
-                                }, [
-                                  ($options.getItemProp(item, 'icon'))
-                                    ? (vue.openBlock(), vue.createElementBlock("span", {
+                                }, $options.getPTOptions(item, 'headerAction')), [
+                                  (_ctx.$slots.headericon)
+                                    ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.$slots.headericon), {
                                         key: 0,
+                                        item: item,
                                         class: vue.normalizeClass($options.getHeaderIconClass(item))
-                                      }, null, 2))
-                                    : vue.createCommentVNode("", true),
-                                  vue.createElementVNode("span", _hoisted_5, vue.toDisplayString($options.getItemLabel(item)), 1)
-                                ], 10, _hoisted_4)
+                                      }, null, 8, ["item", "class"]))
+                                    : ($options.getItemProp(item, 'icon'))
+                                      ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+                                          key: 1,
+                                          class: $options.getHeaderIconClass(item)
+                                        }, $options.getPTOptions(item, 'headerIcon')), null, 16))
+                                      : vue.createCommentVNode("", true),
+                                  vue.createElementVNode("span", vue.mergeProps({ class: "p-menuitem-text" }, $options.getPTOptions(item, 'headerLabel')), vue.toDisplayString($options.getItemLabel(item)), 17)
+                                ], 16, _hoisted_3)
                               ]),
                               _: 2
                             }, 1032, ["to"]))
-                          : (vue.openBlock(), vue.createElementBlock("a", {
+                          : (vue.openBlock(), vue.createElementBlock("a", vue.mergeProps({
                               key: 1,
                               href: $options.getItemProp(item, 'url'),
-                              class: vue.normalizeClass($options.getHeaderActionClass(item)),
+                              class: $options.getHeaderActionClass(item),
                               tabindex: -1
-                            }, [
+                            }, $options.getPTOptions(item, 'headerAction')), [
                               ($options.getItemProp(item, 'items'))
-                                ? (vue.openBlock(), vue.createElementBlock("span", {
+                                ? vue.renderSlot(_ctx.$slots, "submenuicon", {
                                     key: 0,
-                                    class: vue.normalizeClass($options.getHeaderToggleIconClass(item))
-                                  }, null, 2))
+                                    active: $options.isItemActive(item)
+                                  }, () => [
+                                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($options.isItemActive(item) ? 'ChevronDownIcon' : 'ChevronRightIcon'), vue.mergeProps({ class: "p-submenu-icon" }, $options.getPTOptions(item, 'submenuIcon')), null, 16))
+                                  ])
                                 : vue.createCommentVNode("", true),
-                              ($options.getItemProp(item, 'icon'))
-                                ? (vue.openBlock(), vue.createElementBlock("span", {
+                              (_ctx.$slots.headericon)
+                                ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.$slots.headericon), {
                                     key: 1,
+                                    item: item,
                                     class: vue.normalizeClass($options.getHeaderIconClass(item))
-                                  }, null, 2))
-                                : vue.createCommentVNode("", true),
-                              vue.createElementVNode("span", _hoisted_7, vue.toDisplayString($options.getItemLabel(item)), 1)
-                            ], 10, _hoisted_6))
+                                  }, null, 8, ["item", "class"]))
+                                : ($options.getItemProp(item, 'icon'))
+                                  ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+                                      key: 2,
+                                      class: $options.getHeaderIconClass(item)
+                                    }, $options.getPTOptions(item, 'headerIcon')), null, 16))
+                                  : vue.createCommentVNode("", true),
+                              vue.createElementVNode("span", vue.mergeProps({ class: "p-menuitem-text" }, $options.getPTOptions(item, 'headerLabel')), vue.toDisplayString($options.getItemLabel(item)), 17)
+                            ], 16, _hoisted_4))
                       ], 64))
                     : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.$slots.item), {
                         key: 1,
                         item: item
                       }, null, 8, ["item"]))
-                ])
-              ], 42, _hoisted_2),
+                ], 16)
+              ], 16, _hoisted_2),
               vue.createVNode(vue.Transition, { name: "p-toggleable-content" }, {
                 default: vue.withCtx(() => [
-                  vue.withDirectives(vue.createElementVNode("div", {
+                  vue.withDirectives(vue.createElementVNode("div", vue.mergeProps({
                     id: $options.getContentId(index),
                     class: "p-toggleable-content",
                     role: "region",
                     "aria-labelledby": $options.getHeaderId(index)
-                  }, [
+                  }, _ctx.ptm('toggleableContent')), [
                     ($options.getItemProp(item, 'items'))
-                      ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_9, [
+                      ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
+                          key: 0,
+                          class: "p-panelmenu-content"
+                        }, _ctx.ptm('menuContent')), [
                           vue.createVNode(_component_PanelMenuList, {
                             panelId: $options.getPanelId(index),
                             items: $options.getItemProp(item, 'items'),
-                            template: _ctx.$slots.item,
+                            templates: _ctx.$slots,
                             expandedKeys: $props.expandedKeys,
                             onItemToggle: $options.changeExpandedKeys,
                             onHeaderFocus: $options.updateFocusedHeader,
-                            exact: $props.exact
-                          }, null, 8, ["panelId", "items", "template", "expandedKeys", "onItemToggle", "onHeaderFocus", "exact"])
-                        ]))
+                            exact: $props.exact,
+                            pt: _ctx.pt
+                          }, null, 8, ["panelId", "items", "templates", "expandedKeys", "onItemToggle", "onHeaderFocus", "exact", "pt"])
+                        ], 16))
                       : vue.createCommentVNode("", true)
-                  ], 8, _hoisted_8), [
+                  ], 16, _hoisted_5), [
                     [vue.vShow, $options.isItemActive(item)]
                   ])
                 ]),
                 _: 2
               }, 1024)
-            ], 6))
+            ], 16))
           : vue.createCommentVNode("", true)
       ], 64))
     }), 128))
-  ], 8, _hoisted_1))
+  ], 16, _hoisted_1))
 }
 
 function styleInject(css, ref) {