@patternfly/quickstarts 6.2.2 → 6.3.0-prerelease.10

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import * as React from 'react';
-import React__default, { createContext, useCallback, useEffect, useState } from 'react';
+import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
+import { createContext, useState, useCallback, useEffect, useContext, Fragment, useRef, useMemo, useReducer, cloneElement, Children, forwardRef } from 'react';
 import { useIsomorphicLayoutEffect, Tooltip, Alert, CodeBlock, Accordion, AccordionItem, AccordionToggle, AccordionContent, Popover, PopoverPosition, Button, Icon, Flex, FlexItem, Card, CardHeader, CardTitle, CardBody, Stack, Label, CardFooter, Gallery, ToolbarItem, SearchInput, Select, SelectList, SelectOption, MenuToggle, Badge, Toolbar, ToolbarContent, EmptyState, EmptyStateBody, EmptyStateFooter, EmptyStateActions, PageSection, Content, Title, Divider, WizardNavItem, ExpandableSection, List, ListItem, Radio, ActionList, ActionListGroup, ActionListItem, DrawerPanelContent, DrawerHead, DrawerActions, DrawerCloseButton, DrawerPanelBody, Drawer, DrawerContent, DrawerContentBody, StackItem } from '@patternfly/react-core';
 import SearchIcon from '@patternfly/react-icons/dist/js/icons/search-icon';
 import { css } from '@patternfly/react-styles';
@@ -7,6 +7,7 @@ import RocketIcon from '@patternfly/react-icons/dist/js/icons/rocket-icon';
 import { __rest, __awaiter } from 'tslib';
 import { Modal as Modal$1, ModalVariant } from '@patternfly/react-core/deprecated';
 import * as ReactDOM from 'react-dom';
+import { createPortal } from 'react-dom';
 import { renderToStaticMarkup } from 'react-dom/server';
 import CopyIcon from '@patternfly/react-icons/dist/js/icons/copy-icon';
 import LightbulbIcon from '@patternfly/react-icons/dist/js/icons/lightbulb-icon';
@@ -23,18 +24,13 @@ import ArrowRightIcon from '@patternfly/react-icons/dist/js/icons/arrow-right-ic
 import BarsIcon from '@patternfly/react-icons/dist/js/icons/bars-icon';
 
 function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
-    return target;
-  };
-  return _extends.apply(this, arguments);
+    return n;
+  }, _extends.apply(null, arguments);
 }
 
 var m,x=m||(m={});x.Pop="POP";x.Push="PUSH";x.Replace="REPLACE";var y="production"!==process.env.NODE_ENV?function(a){return Object.freeze(a)}:function(a){return a};function z(a,b){if(!a){"undefined"!==typeof console&&console.warn(b);try{throw Error(b);}catch(g){}}}function A(a){a.preventDefault();a.returnValue="";}
@@ -594,27 +590,27 @@ const useValuesForQuickStartContext = (value = {}) => {
     var _a, _b;
     const combinedValue = Object.assign(Object.assign({}, QuickStartContextDefaults), value);
     const { activeQuickStartID, setActiveQuickStartID, setAllQuickStartStates, useQueryParams, allQuickStartStates, allQuickStarts = [], footer, useLegacyHeaderColors, markdown, } = combinedValue;
-    const [quickStarts, setQuickStarts] = React__default.useState(combinedValue.allQuickStarts || []);
-    const [resourceBundle, setResourceBundle] = React__default.useState(Object.assign(Object.assign({}, en), combinedValue.resourceBundle));
-    const [language, setLanguage] = React__default.useState(combinedValue.language);
+    const [quickStarts, setQuickStarts] = useState(combinedValue.allQuickStarts || []);
+    const [resourceBundle, setResourceBundle] = useState(Object.assign(Object.assign({}, en), combinedValue.resourceBundle));
+    const [language, setLanguage] = useState(combinedValue.language);
     const changeResourceBundle = (bundle, lng) => {
         lng && setLanguage(lng);
         setResourceBundle(Object.assign(Object.assign({}, en), bundle));
     };
     const findResource = useCallback((resource, count) => getResource(resource, count !== undefined ? { count } : null, resourceBundle, language), [resourceBundle, language]);
-    const [loading, setLoading] = React__default.useState(combinedValue.loading);
-    const [alwaysShowTaskReview, setAlwaysShowTaskReview] = React__default.useState(combinedValue.alwaysShowTaskReview);
+    const [loading, setLoading] = useState(combinedValue.loading);
+    const [alwaysShowTaskReview, setAlwaysShowTaskReview] = useState(combinedValue.alwaysShowTaskReview);
     const initialSearchParams = new URLSearchParams(window.location.search);
     const initialSearchQuery = initialSearchParams.get(QUICKSTART_SEARCH_FILTER_KEY) || '';
     const initialStatusFilters = ((_a = initialSearchParams.get(QUICKSTART_STATUS_FILTER_KEY)) === null || _a === void 0 ? void 0 : _a.split(',')) || [];
     const quickStartStatusCount = getQuickStartStatusCount(allQuickStartStates, allQuickStarts);
-    const [statusTypes, setStatusTypes] = React__default.useState({
+    const [statusTypes, setStatusTypes] = useState({
         [QuickStartStatus.COMPLETE]: findResource('Complete ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[QuickStartStatus.COMPLETE]),
         [QuickStartStatus.IN_PROGRESS]: findResource('In progress ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[QuickStartStatus.IN_PROGRESS]),
         [QuickStartStatus.NOT_STARTED]: findResource('Not started ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[QuickStartStatus.NOT_STARTED]),
     });
-    const [statusFilters, setStatusFilters] = React__default.useState(initialStatusFilters);
-    const [filterKeyword, setFilterKeyword] = React__default.useState(initialSearchQuery);
+    const [statusFilters, setStatusFilters] = useState(initialStatusFilters);
+    const [filterKeyword, setFilterKeyword] = useState(initialSearchQuery);
     const setFilter = (type, val) => {
         if (type === 'keyword') {
             setFilterKeyword(val);
@@ -623,7 +619,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             setStatusFilters(val);
         }
     };
-    React__default.useEffect(() => {
+    useEffect(() => {
         const updatedQuickStartStatusCount = getQuickStartStatusCount(allQuickStartStates, quickStarts);
         setStatusTypes({
             [QuickStartStatus.COMPLETE]: findResource('Complete ({{statusCount, number}})').replace('{{statusCount, number}}', updatedQuickStartStatusCount[QuickStartStatus.COMPLETE]),
@@ -795,24 +791,18 @@ const useValuesForQuickStartContext = (value = {}) => {
         setAlwaysShowTaskReview,
     };
 };
-const QuickStartContextProvider = ({ children, value }) => (React__default.createElement(QuickStartContext.Provider, { value: useValuesForQuickStartContext(value) }, children));
+const QuickStartContextProvider = ({ children, value }) => (jsx(QuickStartContext.Provider, Object.assign({ value: useValuesForQuickStartContext(value) }, { children: children })));
 
-const Box = ({ children, className }) => (React.createElement("div", { className: css('pfext-status-box', className) }, children));
-const Loading = ({ className }) => (React.createElement("div", { className: css('pfext-m-loader', className) },
-    React.createElement("div", { className: "pfext-m-loader-dot__one" }),
-    React.createElement("div", { className: "pfext-m-loader-dot__two" }),
-    React.createElement("div", { className: "pfext-m-loader-dot__three" })));
+const Box = ({ children, className }) => (jsx("div", Object.assign({ className: css('pfext-status-box', className) }, { children: children })));
+const Loading = ({ className }) => (jsxs("div", Object.assign({ className: css('pfext-m-loader', className) }, { children: [jsx("div", { className: "pfext-m-loader-dot__one" }), jsx("div", { className: "pfext-m-loader-dot__two" }), jsx("div", { className: "pfext-m-loader-dot__three" })] })));
 Loading.displayName = 'Loading';
-const LoadingBox = ({ className, message }) => (React.createElement(Box, { className: css('pfext-status-box--loading', className) },
-    React.createElement(Loading, null),
-    message && React.createElement("div", { className: "pfext-status-box__loading-message" }, message)));
+const LoadingBox = ({ className, message }) => (jsxs(Box, Object.assign({ className: css('pfext-status-box--loading', className) }, { children: [jsx(Loading, {}), message && jsx("div", Object.assign({ className: "pfext-status-box__loading-message" }, { children: message }))] })));
 LoadingBox.displayName = 'LoadingBox';
 const EmptyBox = ({ label }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(Box, null,
-        React.createElement("div", { "data-test": "empty-message", className: "text-center" }, label
-            ? getResource('No {{label}} found').replace('{{label}}', label)
-            : getResource('Not found'))));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsx(Box, { children: jsx("div", Object.assign({ "data-test": "empty-message", className: "text-center" }, { children: label
+                ? getResource('No {{label}} found').replace('{{label}}', label)
+                : getResource('Not found') })) }));
 };
 EmptyBox.displayName = 'EmptyBox';
 
@@ -826,49 +816,47 @@ const CamelCaseWrap = ({ value, dataTest }) => {
     }
     // Add word break points before capital letters (but keep consecutive capital letters together).
     const words = value.match(/[A-Z]+[^A-Z]*|[^A-Z]+/g);
-    const rendered = (React.createElement("span", { "data-test": dataTest }, words.map((word, i) => (React.createElement(React.Fragment, { key: i },
-        word,
-        i !== words.length - 1 && React.createElement("wbr", null))))));
+    const rendered = (jsx("span", Object.assign({ "data-test": dataTest }, { children: words.map((word, i) => (jsxs(Fragment, { children: [word, i !== words.length - 1 && jsx("wbr", {})] }, i))) })));
     MEMO[value] = rendered;
     return rendered;
 };
 
 const Modal = (_a) => {
     var { isFullScreen = false, className } = _a, props = __rest(_a, ["isFullScreen", "className"]);
-    return (React.createElement(Modal$1, Object.assign({}, props, { className: css('pfext-modal', className), appendTo: () => (isFullScreen ? document.body : document.querySelector('#modal-container')) })));
+    return (jsx(Modal$1, Object.assign({}, props, { className: css('pfext-modal', className), appendTo: () => (isFullScreen ? document.body : document.querySelector('#modal-container')) })));
 };
 
 const getContainer = (container) => typeof container === 'function' ? container() : container;
 const Portal = ({ children, container }) => {
-    const [containerNode, setContainerNode] = React.useState();
+    const [containerNode, setContainerNode] = useState();
     useIsomorphicLayoutEffect(() => {
         setContainerNode(getContainer(container) || document.body);
     }, [container]);
-    return containerNode ? ReactDOM.createPortal(children, containerNode) : null;
+    return containerNode ? createPortal(children, containerNode) : null;
 };
 
 const SimplePopper = ({ children }) => {
     const openProp = true;
-    const nodeRef = React.useRef();
-    const popperRef = React.useRef(null);
-    const [isOpen, setOpenState] = React.useState(openProp);
-    const setOpen = React.useCallback((newOpen) => {
+    const nodeRef = useRef(null);
+    const popperRef = useRef(null);
+    const [isOpen, setOpenState] = useState(openProp);
+    const setOpen = useCallback((newOpen) => {
         setOpenState(newOpen);
     }, []);
-    React.useEffect(() => {
+    useEffect(() => {
         setOpen(openProp);
     }, [openProp, setOpen]);
-    const onKeyDown = React.useCallback((e) => {
+    const onKeyDown = useCallback((e) => {
         if (e.keyCode === 27) {
             setOpen(false);
         }
     }, [setOpen]);
-    const onClickOutside = React.useCallback((e) => {
+    const onClickOutside = useCallback((e) => {
         if (!nodeRef.current || (e.target instanceof Node && !nodeRef.current.contains(e.target))) {
             setOpen(false);
         }
     }, [setOpen]);
-    const destroy = React.useCallback(() => {
+    const destroy = useCallback(() => {
         if (popperRef.current) {
             popperRef.current.destroy();
             document.removeEventListener('keydown', onKeyDown, true);
@@ -876,29 +864,28 @@ const SimplePopper = ({ children }) => {
             document.removeEventListener('touchstart', onClickOutside, true);
         }
     }, [onClickOutside, onKeyDown]);
-    const initialize = React.useCallback(() => {
+    const initialize = useCallback(() => {
         if (!nodeRef.current || !isOpen) {
             return;
         }
         destroy();
     }, [isOpen, destroy]);
-    const nodeRefCallback = React.useCallback((node) => {
+    const nodeRefCallback = useCallback((node) => {
         nodeRef.current = node;
         initialize();
     }, [initialize]);
-    React.useEffect(() => {
+    useEffect(() => {
         initialize();
     }, [initialize]);
-    React.useEffect(() => () => {
+    useEffect(() => () => {
         destroy();
     }, [destroy]);
-    React.useEffect(() => {
+    useEffect(() => {
         if (!isOpen) {
             destroy();
         }
     }, [destroy, isOpen]);
-    return isOpen ? (React.createElement(Portal, null,
-        React.createElement("div", { ref: nodeRefCallback, style: { zIndex: 9999, position: 'absolute', top: 0, left: 0 }, className: "pfext-quick-start__base" }, children))) : null;
+    return isOpen ? (jsx(Portal, { children: jsx("div", Object.assign({ ref: nodeRefCallback, style: { zIndex: 9999, position: 'absolute', top: 0, left: 0 }, className: "pfext-quick-start__base" }, { children: children })) })) : null;
 };
 
 const isInViewport = (elementToCheck) => {
@@ -918,8 +905,8 @@ const InteractiveSpotlight = ({ element }) => {
         bottom,
         right,
     };
-    const [clicked, setClicked] = React.useState(false);
-    React.useEffect(() => {
+    const [clicked, setClicked] = useState(false);
+    useEffect(() => {
         if (!clicked) {
             if (!isInViewport(element)) {
                 element.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
@@ -935,9 +922,7 @@ const InteractiveSpotlight = ({ element }) => {
     if (clicked) {
         return null;
     }
-    return (React.createElement(Portal, null,
-        React.createElement(SimplePopper, null,
-            React.createElement("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-animate", style: style }))));
+    return (jsx(Portal, { children: jsx(SimplePopper, { children: jsx("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-animate", style: style }) }) }));
 };
 
 var ScrollDirection;
@@ -949,8 +934,8 @@ var ScrollDirection;
 })(ScrollDirection || (ScrollDirection = {}));
 
 const useResizeObserver = (callback, targetElement, observerOptions = undefined) => {
-    const element = React.useMemo(() => targetElement !== null && targetElement !== void 0 ? targetElement : document.querySelector('body'), [targetElement]);
-    React.useEffect(() => {
+    const element = useMemo(() => targetElement !== null && targetElement !== void 0 ? targetElement : document.querySelector('body'), [targetElement]);
+    useEffect(() => {
         const observer = new ResizeObserver(callback);
         observer.observe(element, observerOptions);
         return () => {
@@ -968,8 +953,8 @@ var Shadows;
 })(Shadows || (Shadows = {}));
 
 const useBoundingClientRect = (targetElement) => {
-    const [clientRect, setClientRect] = React.useState(() => targetElement ? targetElement.getBoundingClientRect() : null);
-    const observerCallback = React.useCallback(() => {
+    const [clientRect, setClientRect] = useState(() => targetElement ? targetElement.getBoundingClientRect() : null);
+    const observerCallback = useCallback(() => {
         setClientRect(targetElement ? targetElement.getBoundingClientRect() : null);
     }, [targetElement]);
     useResizeObserver(observerCallback);
@@ -979,7 +964,7 @@ const useBoundingClientRect = (targetElement) => {
 /**
  * React hook that forces component render.
  */
-const useForceRender = () => React.useReducer((s) => !s, false)[1];
+const useForceRender = () => useReducer((s) => !s, false)[1];
 
 const useEventListener = (target, event, callback) => {
     useEffect(() => {
@@ -1000,14 +985,12 @@ const StaticSpotlight = ({ element }) => {
             width: clientRect.width,
         }
         : {};
-    return clientRect ? (React.createElement(Portal, null,
-        React.createElement("div", { className: "pf-v6-c-backdrop pfext-spotlight__with-backdrop" },
-            React.createElement("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-noanimate", style: style })))) : null;
+    return clientRect ? (jsx(Portal, { children: jsx("div", Object.assign({ className: "pf-v6-c-backdrop pfext-spotlight__with-backdrop" }, { children: jsx("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-noanimate", style: style }) })) })) : null;
 };
 
 const Spotlight = ({ selector, interactive }) => {
     // if target element is a hidden one return null
-    const element = React.useMemo(() => {
+    const element = useMemo(() => {
         const highlightElement = document.querySelector(selector);
         let hiddenElement = highlightElement;
         while (hiddenElement) {
@@ -1022,12 +1005,12 @@ const Spotlight = ({ selector, interactive }) => {
     if (!element) {
         return null;
     }
-    return interactive ? (React.createElement(InteractiveSpotlight, { element: element })) : (React.createElement(StaticSpotlight, { element: element }));
+    return interactive ? (jsx(InteractiveSpotlight, { element: element })) : (jsx(StaticSpotlight, { element: element }));
 };
 
 const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
-    const [selector, setSelector] = React.useState(null);
-    React.useEffect(() => {
+    const [selector, setSelector] = useState(null);
+    useEffect(() => {
         const elements = docContext.querySelectorAll(`${rootSelector} [data-highlight]`);
         let timeoutId;
         function startHighlight(e) {
@@ -1046,7 +1029,7 @@ const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
             elements && elements.forEach((elm) => elm.removeEventListener('click', startHighlight));
         };
     }, [docContext, rootSelector]);
-    React.useEffect(() => {
+    useEffect(() => {
         const elements = docContext.querySelectorAll(`${rootSelector} [class^=data-highlight__]`);
         let timeoutId;
         function startHighlight(e) {
@@ -1076,7 +1059,7 @@ const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
     if (!selector) {
         return null;
     }
-    return React.createElement(Spotlight, { selector: selector, interactive: true });
+    return jsx(Spotlight, { selector: selector, interactive: true });
 };
 
 const MARKDOWN_COPY_BUTTON_ID = 'data-copy-for';
@@ -1084,15 +1067,15 @@ const MARKDOWN_SNIPPET_ID = 'data-snippet-id';
 const ACCORDION_MARKDOWN_BUTTON_ID = `accordion-markdown-button-id`;
 const ACCORDION_MARKDOWN_CONTENT_ID = `accordion-markdown-content-id`;
 
-const CopyClipboard = ({ element, rootSelector, docContext, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    const [showSuccessContent, setShowSuccessContent] = React.useState(false);
-    const textToCopy = React.useMemo(() => {
+const CopyClipboard = ({ element, rootSelector, docContext }) => {
+    const { getResource } = useContext(QuickStartContext);
+    const [showSuccessContent, setShowSuccessContent] = useState(false);
+    const textToCopy = useMemo(() => {
         var _a;
         const copyTextId = element.getAttribute(MARKDOWN_COPY_BUTTON_ID);
         return (_a = docContext.querySelector(`${rootSelector} [${MARKDOWN_SNIPPET_ID}="${copyTextId}"]`)) === null || _a === void 0 ? void 0 : _a.innerText;
     }, [element, docContext, rootSelector]);
-    useEventListener(element, 'click', React.useCallback(() => {
+    useEventListener(element, 'click', useCallback(() => {
         navigator.clipboard
             .writeText(textToCopy.trim())
             .then(() => {
@@ -1100,24 +1083,24 @@ const CopyClipboard = ({ element, rootSelector, docContext, }) => {
         })
             .catch(() => { });
     }, [textToCopy]));
-    useEventListener(element, 'mouseleave', React.useCallback(() => {
+    useEventListener(element, 'mouseleave', useCallback(() => {
         setShowSuccessContent(false);
     }, []));
-    return showSuccessContent ? (React.createElement(Tooltip, { key: "after-copy", isVisible: true, triggerRef: () => element, content: getResource('Successfully copied to clipboard!'), className: "pfext-quick-start__base" })) : (React.createElement(Tooltip, { key: "before-copy", triggerRef: () => element, content: getResource('Copy to clipboard'), className: "pfext-quick-start__base" }));
+    return showSuccessContent ? (jsx(Tooltip, { isVisible: true, triggerRef: () => element, content: getResource('Successfully copied to clipboard!'), className: "pfext-quick-start__base" }, "after-copy")) : (jsx(Tooltip, { triggerRef: () => element, content: getResource('Copy to clipboard'), className: "pfext-quick-start__base" }, "before-copy"));
 };
-const MarkdownCopyClipboard = ({ docContext, rootSelector, }) => {
+const MarkdownCopyClipboard = ({ docContext, rootSelector }) => {
     const elements = docContext.querySelectorAll(`${rootSelector} [${MARKDOWN_COPY_BUTTON_ID}]`);
-    return elements.length > 0 ? (React.createElement(React.Fragment, null, Array.from(elements).map((elm) => {
-        const attributeValue = elm.getAttribute(MARKDOWN_COPY_BUTTON_ID);
-        return (React.createElement(CopyClipboard, { key: attributeValue, element: elm, rootSelector: rootSelector, docContext: docContext }));
-    }))) : null;
+    return elements.length > 0 ? (jsx(Fragment$1, { children: Array.from(elements).map((elm) => {
+            const attributeValue = elm.getAttribute(MARKDOWN_COPY_BUTTON_ID);
+            return (jsx(CopyClipboard, { element: elm, rootSelector: rootSelector, docContext: docContext }, attributeValue));
+        }) })) : null;
 };
 
 const removeTemplateWhitespace = (template) => template.replace(/>(?:\s|\n)+</g, '><');
 
 const useInlineCopyClipboardShowdownExtension = () => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return React.useMemo(() => ({
+    const { getResource } = useContext(QuickStartContext);
+    return useMemo(() => ({
         type: 'lang',
         regex: /`([^`](.*?)[^`])`{{copy}}/g,
         replace: (text, group, _, groupId) => {
@@ -1129,7 +1112,7 @@ const useInlineCopyClipboardShowdownExtension = () => {
               <span class="pf-v6-c-clipboard-copy__actions">
                 <span class="pf-v6-c-clipboard-copy__actions-item">
                   <button class="pf-v6-c-button pf-m-plain" aria-label="${getResource('Copy to clipboard')}" ${MARKDOWN_COPY_BUTTON_ID}="${groupId}">
-                    ${renderToStaticMarkup(React.createElement(CopyIcon, null))}
+                    ${renderToStaticMarkup(jsx(CopyIcon, {}))}
                   </button>
                 </span>
               </span>
@@ -1138,10 +1121,9 @@ const useInlineCopyClipboardShowdownExtension = () => {
     }), [getResource]);
 };
 
-/* eslint-disable max-len */
 const useMultilineCopyClipboardShowdownExtension = () => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return React.useMemo(() => ({
+    const { getResource } = useContext(QuickStartContext);
+    return useMemo(() => ({
         type: 'lang',
         regex: /```[\n]\s*((((?!```).)*?\n)+)\s*```{{copy}}/g,
         replace: (text, group, _1, _2, groupId) => {
@@ -1153,7 +1135,7 @@ const useMultilineCopyClipboardShowdownExtension = () => {
                 <div class="pf-v6-c-code-block__actions">
                   <div class="pf-v6-c-code-block__actions-item">
                     <button class="pf-v6-c-button pf-m-plain" type="button" aria-label="${getResource('Copy to clipboard')}" ${MARKDOWN_COPY_BUTTON_ID}="${groupId}">
-                      ${renderToStaticMarkup(React.createElement(CopyIcon, null))}
+                      ${renderToStaticMarkup(jsx(CopyIcon, {}))}
                     </button>
                   </div>
                 </div>
@@ -1166,6 +1148,155 @@ const useMultilineCopyClipboardShowdownExtension = () => {
     }), [getResource]);
 };
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const DOMPurify$2 = require('dompurify');
+var AdmonitionType;
+(function (AdmonitionType) {
+    AdmonitionType["TIP"] = "TIP";
+    AdmonitionType["NOTE"] = "NOTE";
+    AdmonitionType["IMPORTANT"] = "IMPORTANT";
+    AdmonitionType["WARNING"] = "WARNING";
+    AdmonitionType["CAUTION"] = "CAUTION";
+})(AdmonitionType || (AdmonitionType = {}));
+const admonitionToAlertVariantMap = {
+    [AdmonitionType.NOTE]: { variant: 'info' },
+    [AdmonitionType.TIP]: { variant: 'custom', customIcon: jsx(LightbulbIcon, {}) },
+    [AdmonitionType.IMPORTANT]: { variant: 'danger' },
+    [AdmonitionType.CAUTION]: { variant: 'warning', customIcon: jsx(FireIcon, {}) },
+    [AdmonitionType.WARNING]: { variant: 'warning' },
+};
+const useAdmonitionShowdownExtension = () => 
+// const { getResource } = React.useContext<QuickStartContextValues>(QuickStartContext);
+useMemo(() => ({
+    type: 'lang',
+    regex: /\[(.+)]{{(admonition) ([\w-]+)}}/g,
+    replace: (text, content, admonitionLabel, admonitionType) => {
+        if (!content || !admonitionLabel || !admonitionType) {
+            return text;
+        }
+        if (admonitionLabel !== 'admonition') {
+            return text;
+        }
+        admonitionType = admonitionType.toUpperCase();
+        // Process markdown content directly using marked
+        const processedContent = marked.parseInline(content);
+        const sanitizedContent = DOMPurify$2.sanitize(processedContent);
+        // Handle unknown admonition types by defaulting to NOTE
+        const admonitionConfig = admonitionToAlertVariantMap[admonitionType] || admonitionToAlertVariantMap.NOTE;
+        const { variant, customIcon } = admonitionConfig;
+        const pfAlert = (jsx(Alert, Object.assign({ variant: variant }, (customIcon && { customIcon }), { isInline: true, title: admonitionType, className: "pfext-markdown-admonition" }, { children: jsx("div", { dangerouslySetInnerHTML: { __html: sanitizedContent } }) })));
+        return removeTemplateWhitespace(renderToStaticMarkup(pfAlert));
+    },
+}), []);
+
+const useCodeShowdownExtension = () => useMemo(() => ({
+    type: 'output',
+    regex: /<pre><code>(.*?)\n?<\/code><\/pre>/g,
+    replace: (text, content) => {
+        if (!content) {
+            return text;
+        }
+        const pfCodeBlock = jsx(CodeBlock, { children: content });
+        return removeTemplateWhitespace(renderToStaticMarkup(pfCodeBlock));
+    },
+}), []);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const DOMPurify$1 = require('dompurify');
+const useAccordionShowdownExtension = () => useMemo(() => ({
+    type: 'lang',
+    regex: /\[(.+)]{{(accordion) (&quot;(.*?)&quot;)}}/g,
+    replace: (_text, accordionContent, _command, _quotedHeading, accordionHeading) => {
+        const accordionId = String(accordionHeading).replace(/\s/g, '-');
+        // Process accordion content with markdown
+        const processedContent = marked.parseInline(accordionContent);
+        const sanitizedContent = DOMPurify$1.sanitize(processedContent);
+        return removeTemplateWhitespace(renderToStaticMarkup(jsx(Accordion, { children: jsxs(AccordionItem, { children: [jsx(AccordionToggle, Object.assign({ id: `${ACCORDION_MARKDOWN_BUTTON_ID}-${accordionId}` }, { children: accordionHeading })), jsx(AccordionContent, Object.assign({ id: `${ACCORDION_MARKDOWN_CONTENT_ID}-${accordionId}`, hidden: true }, { children: jsx("div", { dangerouslySetInnerHTML: { __html: sanitizedContent } }) }))] }) })));
+    },
+}), []);
+
+const AccordionShowdownHandler = ({ buttonElement, contentElement, }) => {
+    const [expanded, setExpanded] = useState(false);
+    const handleClick = () => {
+        const newExpanded = !expanded;
+        const expandedModifier = 'pf-m-expanded';
+        // Find the accordion item element (parent of the button)
+        const accordionItem = buttonElement.closest('.pf-v6-c-accordion__item');
+        // Update button - both visual state and aria-expanded
+        buttonElement.className = `pf-v6-c-accordion__toggle ${newExpanded ? expandedModifier : ''}`;
+        buttonElement.setAttribute('aria-expanded', newExpanded.toString());
+        // Update content - both visual state and hidden attribute
+        contentElement.hidden = !newExpanded;
+        contentElement.className = `pf-v6-c-accordion__expandable-content ${newExpanded ? expandedModifier : ''}`;
+        // Update accordion item
+        if (accordionItem) {
+            accordionItem.className = `pf-v6-c-accordion__item ${newExpanded ? expandedModifier : ''}`;
+        }
+        setExpanded(newExpanded);
+    };
+    useEventListener(buttonElement, 'click', handleClick);
+    return jsx(Fragment$1, {});
+};
+const AccordionRenderExtension = ({ docContext }) => {
+    const buttonElements = docContext.querySelectorAll(`[id ^= ${ACCORDION_MARKDOWN_BUTTON_ID}]`);
+    const contentElements = docContext.querySelectorAll(`[id ^= ${ACCORDION_MARKDOWN_CONTENT_ID}]`);
+    return buttonElements.length > 0 ? (jsx(Fragment$1, { children: Array.from(buttonElements).map((elm) => {
+            const content = Array.from(contentElements).find((elm2) => {
+                const elmId = elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1];
+                const elm2Id = elm2.id.split(ACCORDION_MARKDOWN_CONTENT_ID)[1];
+                return elmId === elm2Id;
+            });
+            return (jsx(AccordionShowdownHandler, { buttonElement: elm, contentElement: content }, elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1]));
+        }) })) : null;
+};
+
+const FallbackImg = ({ src, alt, className, fallback }) => {
+    const [isSrcValid, setIsSrcValid] = useState(true);
+    if (src && isSrcValid) {
+        return jsx("img", { className: className, src: src, alt: alt, onError: () => setIsSrcValid(false) });
+    }
+    return jsx(Fragment$1, { children: fallback });
+};
+
+const DASH = '-';
+
+const PopoverStatus = ({ hideHeader, children, isVisible = null, statusBody, title, onHide, onShow, }) => (jsx(Popover, Object.assign({ position: PopoverPosition.right, headerContent: hideHeader ? null : title, bodyContent: children, "aria-label": title, onHide: onHide, onShow: onShow, isVisible: isVisible }, { children: jsx(Button, Object.assign({ variant: "link", isInline: true }, { children: statusBody })) })));
+
+const StatusIconAndText = ({ icon, title, spin, iconOnly, noTooltip, className, }) => {
+    if (!title) {
+        return jsx(Fragment$1, { children: DASH });
+    }
+    return (jsxs("span", Object.assign({ className: css('pfext-icon-and-text', className), title: iconOnly && !noTooltip ? title : undefined }, { children: [icon &&
+                cloneElement(icon, {
+                    className: css(spin && 'fa-spin', icon.props.className, !iconOnly && 'pfext-icon-and-text__icon pfext-icon-flex-child'),
+                }), !iconOnly && jsx(CamelCaseWrap, { value: title, dataTest: "status-text" })] })));
+};
+
+const GenericStatus = (props) => {
+    const { Icon, children, popoverTitle, title, noTooltip, iconOnly } = props, restProps = __rest(props, ["Icon", "children", "popoverTitle", "title", "noTooltip", "iconOnly"]);
+    const renderIcon = iconOnly && !noTooltip ? jsx(Icon, { title: title }) : jsx(Icon, {});
+    const statusBody = (jsx(StatusIconAndText, Object.assign({}, restProps, { noTooltip: noTooltip, title: title, iconOnly: iconOnly, icon: renderIcon })));
+    return Children.toArray(children).length ? (jsx(PopoverStatus, Object.assign({ title: popoverTitle || title }, restProps, { statusBody: statusBody }, { children: children }))) : (statusBody);
+};
+
+const GreenCheckCircleIcon = ({ className, title, size }) => (jsx(Icon, Object.assign({ size: size, status: "success" }, { children: jsx(CheckCircleIcon, { "data-test": "success-icon", className: className, title: title }) })));
+
+const SuccessStatus = (props) => (jsx(GenericStatus, Object.assign({}, props, { Icon: GreenCheckCircleIcon, title: props.title || 'Healthy' })));
+SuccessStatus.displayName = 'SuccessStatus';
+
+const Status = ({ status, title, iconOnly, noTooltip, className }) => {
+    const statusProps = { title: title || status, iconOnly, noTooltip, className };
+    switch (status) {
+        case 'In Progress':
+            return jsx(StatusIconAndText, Object.assign({}, statusProps, { icon: jsx(SyncAltIcon, {}) }));
+        case 'Complete':
+            return jsx(SuccessStatus, Object.assign({}, statusProps));
+        default:
+            return jsx(Fragment$1, { children: status || DASH });
+    }
+};
+const StatusIcon = ({ status }) => jsx(Status, { status: status, iconOnly: true });
+
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const DOMPurify = require('dompurify');
 const markdownConvert = (markdown, extensions) => __awaiter(void 0, void 0, void 0, function* () {
@@ -1177,7 +1308,7 @@ const markdownConvert = (markdown, extensions) => __awaiter(void 0, void 0, void
             node.setAttribute('rel', 'noopener noreferrer');
             return node;
         }
-        // add PF content classes
+        // add PF content classes to standard elements (details blocks get handled separately)
         if (node.nodeType === 1) {
             const contentElements = [
                 'ul',
@@ -1228,13 +1359,82 @@ const markdownConvert = (markdown, extensions) => __awaiter(void 0, void 0, void
     const reversedMarkdown = reverseString(markdown);
     const reverseMarkdownWithSubstitutedCodeFences = reversedMarkdown.replace(/{{```((.|\n)*?)```/g, '{{@@@$1@@@');
     const markdownWithSubstitutedCodeFences = reverseString(reverseMarkdownWithSubstitutedCodeFences);
-    const parsedMarkdown = yield marked.parse(markdownWithSubstitutedCodeFences);
+    // Fix malformed HTML entities early in the process
+    let preprocessedMarkdown = markdownWithSubstitutedCodeFences;
+    preprocessedMarkdown = preprocessedMarkdown
+        .replace(/&nbsp([^;])/g, '&nbsp;$1')
+        .replace(/&amp;nbsp;/g, '&nbsp;');
+    preprocessedMarkdown = preprocessedMarkdown.replace(/&nbsp(?![;])/g, '&nbsp;');
+    // Process content in segments to ensure markdown parsing continues after HTML blocks
+    const htmlBlockRegex = /(<(?:details|div|section|article)[^>]*>[\s\S]*?<\/(?:details|div|section|article)>)/g;
+    let parsedMarkdown = '';
+    // Check if there are any HTML blocks
+    if (htmlBlockRegex.test(preprocessedMarkdown)) {
+        // Reset regex for actual processing
+        htmlBlockRegex.lastIndex = 0;
+        let lastIndex = 0;
+        let match;
+        while ((match = htmlBlockRegex.exec(preprocessedMarkdown)) !== null) {
+            // Process markdown before the HTML block
+            const markdownBefore = preprocessedMarkdown.slice(lastIndex, match.index).trim();
+            if (markdownBefore) {
+                const parsed = yield marked.parse(markdownBefore);
+                parsedMarkdown += parsed;
+            }
+            // Process the HTML block: parse markdown content inside while preserving HTML structure
+            let htmlBlock = match[1];
+            // Find and process markdown content inside HTML tags
+            const contentRegex = />(\s*[\s\S]*?)\s*</g;
+            const contentMatches = [];
+            let contentMatch;
+            while ((contentMatch = contentRegex.exec(htmlBlock)) !== null) {
+                const content = contentMatch[1];
+                // Only process content that has markdown formatting but no extension syntax
+                if (content.trim() &&
+                    !content.includes('{{') &&
+                    (content.includes('**') || content.includes('- ') || content.includes('\n'))) {
+                    // This looks like markdown content without extensions - parse it as block content
+                    const parsedContent = yield marked.parse(content.trim());
+                    // Remove wrapping <p> tags if they exist since we're inside HTML already
+                    const cleanedContent = parsedContent.replace(/^<p[^>]*>([\s\S]*)<\/p>[\s]*$/g, '$1');
+                    contentMatches.push({
+                        original: contentMatch[0],
+                        replacement: `>${cleanedContent}<`,
+                    });
+                }
+            }
+            // Apply the content replacements
+            contentMatches.forEach(({ original, replacement }) => {
+                htmlBlock = htmlBlock.replace(original, replacement);
+            });
+            // Apply extensions (like admonitions) to the processed HTML block
+            if (extensions) {
+                extensions.forEach(({ regex, replace }) => {
+                    if (regex) {
+                        htmlBlock = htmlBlock.replace(regex, replace);
+                    }
+                });
+            }
+            parsedMarkdown += htmlBlock;
+            lastIndex = htmlBlockRegex.lastIndex;
+        }
+        // Process any remaining markdown after the last HTML block
+        const markdownAfter = preprocessedMarkdown.slice(lastIndex).trim();
+        if (markdownAfter) {
+            const parsed = yield marked.parse(markdownAfter);
+            parsedMarkdown += parsed;
+        }
+    }
+    else {
+        // No HTML blocks found, process normally
+        parsedMarkdown = yield marked.parse(preprocessedMarkdown);
+    }
     // Swap the temporary tokens back to code fences before we run the extensions
     let md = parsedMarkdown.replace(/@@@/g, '```');
     if (extensions) {
         // Convert code spans back to md format before we run the custom extension regexes
         md = md.replace(/<code>(.*)<\/code>/g, '`$1`');
-        extensions.forEach(({ regex, replace }) => {
+        extensions.forEach(({ regex, replace }, _index) => {
             if (regex) {
                 md = md.replace(regex, replace);
             }
@@ -1245,9 +1445,9 @@ const markdownConvert = (markdown, extensions) => __awaiter(void 0, void 0, void
     return DOMPurify.sanitize(md);
 });
 const SyncMarkdownView = ({ content, emptyMsg, extensions, renderExtension, exactHeight, inline, className, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    const [markup, setMarkup] = React.useState('');
-    React.useEffect(() => {
+    const { getResource } = useContext(QuickStartContext);
+    const [markup, setMarkup] = useState('');
+    useEffect(() => {
         function getMd() {
             return __awaiter(this, void 0, void 0, function* () {
                 const md = yield markdownConvert(content || emptyMsg || getResource('Not available'), extensions);
@@ -1263,7 +1463,7 @@ const SyncMarkdownView = ({ content, emptyMsg, extensions, renderExtension, exac
         isEmpty: !content,
         className,
     };
-    return inline ? React.createElement(InlineMarkdownView, Object.assign({}, innerProps)) : React.createElement(IFrameMarkdownView, Object.assign({}, innerProps));
+    return inline ? jsx(InlineMarkdownView, Object.assign({}, innerProps)) : jsx(IFrameMarkdownView, Object.assign({}, innerProps));
 };
 const uniqueId = (function () {
     let num = 0;
@@ -1275,8 +1475,8 @@ const uniqueId = (function () {
 })();
 const RenderExtension = ({ renderExtension, selector, markup, docContext, }) => {
     const forceRender = useForceRender();
-    const markupRef = React.useRef(null);
-    const shouldRenderExtension = React.useCallback(() => {
+    const markupRef = useRef(null);
+    const shouldRenderExtension = useCallback(() => {
         if (markupRef.current === markup) {
             return true;
         }
@@ -1289,25 +1489,23 @@ const RenderExtension = ({ renderExtension, selector, markup, docContext, }) =>
      * which causes the component rendered by renderExtension to receive old copy of document
      * use forceRender to delay the rendering of extension by one render cycle
      */
-    React.useEffect(() => {
+    useEffect(() => {
         if (renderExtension) {
             forceRender();
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [markup]);
-    return (React.createElement(React.Fragment, null, shouldRenderExtension() ? renderExtension === null || renderExtension === void 0 ? void 0 : renderExtension(docContext !== null && docContext !== void 0 ? docContext : document, selector) : null));
+    return (jsx(Fragment$1, { children: shouldRenderExtension() ? renderExtension === null || renderExtension === void 0 ? void 0 : renderExtension(docContext !== null && docContext !== void 0 ? docContext : document, selector) : null }));
 };
 const InlineMarkdownView = ({ markup, isEmpty, renderExtension, className, }) => {
-    const id = React.useMemo(() => uniqueId('markdown'), []);
-    return (React.createElement("div", { className: css({ 'is-empty': isEmpty }, className), id: id },
-        React.createElement("div", { dangerouslySetInnerHTML: { __html: markup } }),
-        renderExtension && (React.createElement(RenderExtension, { renderExtension: renderExtension, selector: `#${id}`, markup: markup }))));
+    const id = useMemo(() => uniqueId('markdown'), []);
+    return (jsxs("div", Object.assign({ className: css({ 'is-empty': isEmpty }, className), id: id }, { children: [jsx("div", { style: { marginBlockEnd: 'var(--pf-t-global--spacer--md)' }, dangerouslySetInnerHTML: { __html: markup } }), renderExtension && (jsx(RenderExtension, { renderExtension: renderExtension, selector: `#${id}`, markup: markup }))] })));
 };
 const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, className, }) => {
-    const [frame, setFrame] = React.useState();
-    const [loaded, setLoaded] = React.useState(false);
-    const updateTimeoutHandle = React.useRef();
-    const updateDimensions = React.useCallback(() => {
+    const [frame, setFrame] = useState();
+    const [loaded, setLoaded] = useState(false);
+    const updateTimeoutHandle = useRef(null);
+    const updateDimensions = useCallback(() => {
         var _a;
         if (!((_a = frame === null || frame === void 0 ? void 0 : frame.contentWindow) === null || _a === void 0 ? void 0 : _a.document.body.firstChild)) {
             return;
@@ -1324,10 +1522,10 @@ const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, cla
             }
         });
     }, [frame, exactHeight]);
-    React.useEffect(() => () => {
+    useEffect(() => () => {
         clearTimeout(updateTimeoutHandle.current);
     }, []);
-    const onLoad = React.useCallback(() => {
+    const onLoad = useCallback(() => {
         updateDimensions();
         setLoaded(true);
     }, [updateDimensions]);
@@ -1360,9 +1558,9 @@ const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, cla
   }
   </style>
   <body class="pf-m-redhat-font"><div style="overflow-y: auto;">${markup}</div></body>`;
-    return (React.createElement(React.Fragment, null,
-        React.createElement("iframe", { sandbox: "allow-popups allow-popups-to-escape-sandbox allow-same-origin", srcDoc: contents, style: { border: '0px', display: 'block', width: '100%', height: '0' }, ref: (r) => setFrame(r), onLoad: () => onLoad(), className: className }),
-        loaded && frame && renderExtension && (React.createElement(RenderExtension, { markup: markup, selector: '', renderExtension: renderExtension, docContext: frame.contentDocument }))));
+    return (jsxs(Fragment$1, { children: [jsx("iframe", { title: "Markdown content preview", sandbox: "allow-popups allow-popups-to-escape-sandbox allow-same-origin", srcDoc: contents, style: { border: '0px', display: 'block', width: '100%', height: '0' }, ref: (r) => {
+                    setFrame(r);
+                }, onLoad: () => onLoad(), className: className }), loaded && frame && renderExtension && (jsx(RenderExtension, { markup: markup, selector: '', renderExtension: renderExtension, docContext: frame.contentDocument }))] }));
 };
 
 const LINK_LABEL = '[\\d\\w\\s-()$!]+';
@@ -1372,13 +1570,13 @@ const SELECTOR_ID = `[\\w-]+`;
 const HIGHLIGHT_REGEXP = new RegExp(`\\[(${LINK_LABEL})]{{(${HIGHLIGHT_ACTIONS.join('|')}) (${SELECTOR_ID})}}`, 'g');
 
 const QuickStartMarkdownView = ({ content, exactHeight, className, }) => {
-    const { markdown } = React.useContext(QuickStartContext);
+    const { markdown } = useContext(QuickStartContext);
     const inlineCopyClipboardShowdownExtension = useInlineCopyClipboardShowdownExtension();
     const multilineCopyClipboardShowdownExtension = useMultilineCopyClipboardShowdownExtension();
     const admonitionShowdownExtension = useAdmonitionShowdownExtension();
     const codeShowdownExtension = useCodeShowdownExtension();
     const accordionShowdownExtension = useAccordionShowdownExtension();
-    return (React.createElement(SyncMarkdownView, { inline: true, content: content, exactHeight: exactHeight, extensions: [
+    return (jsx(SyncMarkdownView, { inline: true, content: content, exactHeight: exactHeight, extensions: [
             {
                 type: 'lang',
                 regex: HIGHLIGHT_REGEXP,
@@ -1403,203 +1601,45 @@ const QuickStartMarkdownView = ({ content, exactHeight, className, }) => {
             codeShowdownExtension,
             accordionShowdownExtension,
             ...(markdown ? markdown.extensions : []),
-        ], renderExtension: (docContext, rootSelector) => (React.createElement(React.Fragment, null,
-            React.createElement(AccordionRenderExtension, { docContext: docContext }),
-            React.createElement(MarkdownHighlightExtension, { docContext: docContext, rootSelector: rootSelector }),
-            React.createElement(MarkdownCopyClipboard, { docContext: docContext, rootSelector: rootSelector }),
-            markdown &&
-                markdown.renderExtension &&
-                markdown.renderExtension(docContext, rootSelector))), className: className }));
-};
-
-var AdmonitionType;
-(function (AdmonitionType) {
-    AdmonitionType["TIP"] = "TIP";
-    AdmonitionType["NOTE"] = "NOTE";
-    AdmonitionType["IMPORTANT"] = "IMPORTANT";
-    AdmonitionType["WARNING"] = "WARNING";
-    AdmonitionType["CAUTION"] = "CAUTION";
-})(AdmonitionType || (AdmonitionType = {}));
-const admonitionToAlertVariantMap = {
-    [AdmonitionType.NOTE]: { variant: 'info' },
-    [AdmonitionType.TIP]: { variant: 'custom', customIcon: React.createElement(LightbulbIcon, null) },
-    [AdmonitionType.IMPORTANT]: { variant: 'danger' },
-    [AdmonitionType.CAUTION]: { variant: 'warning', customIcon: React.createElement(FireIcon, null) },
-    [AdmonitionType.WARNING]: { variant: 'warning' },
-};
-const useAdmonitionShowdownExtension = () => 
-// const { getResource } = React.useContext<QuickStartContextValues>(QuickStartContext);
-React.useMemo(() => ({
-    type: 'lang',
-    regex: /\[(.+)]{{(admonition) ([\w-]+)}}/g,
-    replace: (text, content, admonitionLabel, admonitionType, groupId) => {
-        if (!content || !admonitionLabel || !admonitionType || !groupId) {
-            return text;
-        }
-        admonitionType = admonitionType.toUpperCase();
-        const { variant, customIcon } = admonitionToAlertVariantMap[admonitionType];
-        const mdContent = React.createElement(QuickStartMarkdownView, { content: content });
-        const pfAlert = (React.createElement(Alert, Object.assign({ variant: variant }, (customIcon && { customIcon }), { isInline: true, title: admonitionType, className: "pfext-markdown-admonition" }), mdContent));
-        return removeTemplateWhitespace(renderToStaticMarkup(pfAlert));
-    },
-}), []);
-
-const useCodeShowdownExtension = () => React.useMemo(() => ({
-    type: 'output',
-    regex: /<pre><code>(.*?)\n?<\/code><\/pre>/g,
-    replace: (text, content) => {
-        if (!content) {
-            return text;
-        }
-        const pfCodeBlock = React.createElement(CodeBlock, null, content);
-        return removeTemplateWhitespace(renderToStaticMarkup(pfCodeBlock));
-    },
-}), []);
-
-const useAccordionShowdownExtension = () => React.useMemo(() => ({
-    type: 'lang',
-    regex: /\[(.+)]{{(accordion) ("(.*?)")}}/g,
-    replace: (_text, accordionContent, _command, accordionHeading) => {
-        const accordionId = String(accordionHeading).replace(/\s/g, '-');
-        return removeTemplateWhitespace(renderToStaticMarkup(React.createElement(React.Fragment, null,
-            React.createElement(Accordion, { asDefinitionList: true },
-                React.createElement(AccordionItem, { isExpanded: false },
-                    React.createElement(AccordionToggle, { id: `${ACCORDION_MARKDOWN_BUTTON_ID}-${accordionId}` }, accordionHeading),
-                    React.createElement(AccordionContent, { id: `${ACCORDION_MARKDOWN_CONTENT_ID}-${accordionId}` }, accordionContent))))));
-    },
-}), []);
-
-const AccordionShowdownHandler = ({ buttonElement, contentElement, }) => {
-    const [expanded, setExpanded] = React.useState(false);
-    const handleClick = () => {
-        const expandedModifier = 'pf-m-expanded';
-        buttonElement.className = `pf-v6-c-accordion__toggle ${!expanded ? expandedModifier : ''}`;
-        contentElement.hidden = expanded;
-        contentElement.className = `pf-v6-c-accordion__expanded-content ${!expanded ? expandedModifier : ''}`;
-        setExpanded(!expanded);
-    };
-    useEventListener(buttonElement, 'click', handleClick);
-    return React.createElement(React.Fragment, null);
-};
-const AccordionRenderExtension = ({ docContext }) => {
-    const buttonElements = docContext.querySelectorAll(`[id ^= ${ACCORDION_MARKDOWN_BUTTON_ID}]`);
-    const contentElements = docContext.querySelectorAll(`[id ^= ${ACCORDION_MARKDOWN_CONTENT_ID}]`);
-    return buttonElements.length > 0 ? (React.createElement(React.Fragment, null, Array.from(buttonElements).map((elm) => {
-        const content = Array.from(contentElements).find((elm2) => {
-            const elmId = elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1];
-            const elm2Id = elm2.id.split(ACCORDION_MARKDOWN_CONTENT_ID)[1];
-            return elmId === elm2Id;
-        });
-        return (React.createElement(AccordionShowdownHandler, { key: elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1], buttonElement: elm, contentElement: content }));
-    }))) : null;
-};
-
-const FallbackImg = ({ src, alt, className, fallback }) => {
-    const [isSrcValid, setIsSrcValid] = React.useState(true);
-    if (src && isSrcValid) {
-        return React.createElement("img", { className: className, src: src, alt: alt, onError: () => setIsSrcValid(false) });
-    }
-    return React.createElement(React.Fragment, null, fallback);
-};
-
-const DASH = '-';
-
-const PopoverStatus = ({ hideHeader, children, isVisible = null, statusBody, title, onHide, onShow, }) => (React.createElement(Popover, { position: PopoverPosition.right, headerContent: hideHeader ? null : title, bodyContent: children, "aria-label": title, onHide: onHide, onShow: onShow, isVisible: isVisible },
-    React.createElement(Button, { variant: "link", isInline: true }, statusBody)));
-
-const StatusIconAndText = ({ icon, title, spin, iconOnly, noTooltip, className, }) => {
-    if (!title) {
-        return React.createElement(React.Fragment, null, DASH);
-    }
-    return (React.createElement("span", { className: css('pfext-icon-and-text', className), title: iconOnly && !noTooltip ? title : undefined },
-        icon &&
-            React.cloneElement(icon, {
-                className: css(spin && 'fa-spin', icon.props.className, !iconOnly && 'pfext-icon-and-text__icon pfext-icon-flex-child'),
-            }),
-        !iconOnly && React.createElement(CamelCaseWrap, { value: title, dataTest: "status-text" })));
-};
-
-const GenericStatus = (props) => {
-    const { Icon, children, popoverTitle, title, noTooltip, iconOnly } = props, restProps = __rest(props, ["Icon", "children", "popoverTitle", "title", "noTooltip", "iconOnly"]);
-    const renderIcon = iconOnly && !noTooltip ? React.createElement(Icon, { title: title }) : React.createElement(Icon, null);
-    const statusBody = (React.createElement(StatusIconAndText, Object.assign({}, restProps, { noTooltip: noTooltip, title: title, iconOnly: iconOnly, icon: renderIcon })));
-    return React.Children.toArray(children).length ? (React.createElement(PopoverStatus, Object.assign({ title: popoverTitle || title }, restProps, { statusBody: statusBody }), children)) : (statusBody);
-};
-
-const GreenCheckCircleIcon = ({ className, title, size }) => (React.createElement(Icon, { size: size, status: "success" },
-    React.createElement(CheckCircleIcon, { "data-test": "success-icon", className: className, title: title })));
-
-const SuccessStatus = (props) => (React.createElement(GenericStatus, Object.assign({}, props, { Icon: GreenCheckCircleIcon, title: props.title || 'Healthy' })));
-SuccessStatus.displayName = 'SuccessStatus';
-
-const Status = ({ status, title, iconOnly, noTooltip, className, }) => {
-    const statusProps = { title: title || status, iconOnly, noTooltip, className };
-    switch (status) {
-        case 'In Progress':
-            return React.createElement(StatusIconAndText, Object.assign({}, statusProps, { icon: React.createElement(SyncAltIcon, null) }));
-        case 'Complete':
-            return React.createElement(SuccessStatus, Object.assign({}, statusProps));
-        default:
-            return React.createElement(React.Fragment, null, status || DASH);
-    }
+        ], renderExtension: (docContext, rootSelector) => (jsxs(Fragment$1, { children: [jsx(AccordionRenderExtension, { docContext: docContext }), jsx(MarkdownHighlightExtension, { docContext: docContext, rootSelector: rootSelector }), jsx(MarkdownCopyClipboard, { docContext: docContext, rootSelector: rootSelector }), markdown &&
+                    markdown.renderExtension &&
+                    markdown.renderExtension(docContext, rootSelector)] })), className: className }));
 };
-const StatusIcon = ({ status }) => (React.createElement(Status, { status: status, iconOnly: true }));
 
 const QuickStartTileDescription = ({ description, prerequisites, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
+    const { getResource } = useContext(QuickStartContext);
     const prereqs = prerequisites === null || prerequisites === void 0 ? void 0 : prerequisites.filter((p) => p);
-    const buttonRef = React.useRef(null);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(QuickStartMarkdownView, { content: description }),
-        (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (React.createElement(Flex, { spaceItems: { default: 'spaceItemsSm' } },
-            React.createElement("h5", null,
-                getResource('Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length),
-                ' '),
-            React.createElement(Button, { variant: "link", isInline: true, "data-testid": "qs-card-prereqs", ref: buttonRef, onClick: (e) => {
-                    e.preventDefault();
-                    e.stopPropagation();
-                }, "aria-label": getResource('Show prerequisites') },
-                React.createElement(InfoCircleIcon, null)),
-            React.createElement(Popover, { "aria-label": getResource('Prerequisites'), headerContent: getResource('Prerequisites'), triggerRef: buttonRef, bodyContent: React.createElement("div", null,
-                    React.createElement("ul", { "aria-label": getResource('Prerequisites') }, prereqs.map((prerequisite, index) => (
-                    // eslint-disable-next-line react/no-array-index-key
-                    React.createElement("li", { key: index },
-                        React.createElement(QuickStartMarkdownView, { content: prerequisite })))))) })))));
+    const buttonRef = useRef(null);
+    return (jsxs(Fragment$1, { children: [jsx(QuickStartMarkdownView, { content: description }), (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (jsxs(Flex, Object.assign({ spaceItems: { default: 'spaceItemsSm' } }, { children: [jsxs("h5", { children: [getResource('Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), ' '] }), jsx(Button, Object.assign({ variant: "link", isInline: true, "data-testid": "qs-card-prereqs", ref: buttonRef, onClick: (e) => {
+                            e.preventDefault();
+                            e.stopPropagation();
+                        }, "aria-label": getResource('Show prerequisites') }, { children: jsx(InfoCircleIcon, {}) })), jsx(Popover, { "aria-label": getResource('Prerequisites'), headerContent: getResource('Prerequisites'), triggerRef: buttonRef, bodyContent: jsx("div", { children: jsx("ul", Object.assign({ "aria-label": getResource('Prerequisites') }, { children: prereqs.map((prerequisite, index) => (
+                                // eslint-disable-next-line react/no-array-index-key
+                                jsx("li", { children: jsx(QuickStartMarkdownView, { content: prerequisite }) }, index))) })) }) })] })))] }));
 };
 
 const QuickStartTileFooter = ({ quickStartId, status, totalTasks, onClickContinue, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    const { activeQuickStartID, startQuickStart, restartQuickStart } = React.useContext(QuickStartContext);
-    const start = React.useCallback(() => {
+    const { getResource } = useContext(QuickStartContext);
+    const { activeQuickStartID, startQuickStart, restartQuickStart } = useContext(QuickStartContext);
+    const start = useCallback(() => {
         startQuickStart(quickStartId, totalTasks);
     }, [quickStartId, startQuickStart, totalTasks]);
-    const restart = React.useCallback(() => {
+    const restart = useCallback(() => {
         restartQuickStart(quickStartId, totalTasks);
     }, [quickStartId, restartQuickStart, totalTasks]);
-    return (React.createElement(Flex, { justifyContent: { default: 'justifyContentSpaceBetween' } },
-        status === QuickStartStatus.NOT_STARTED && (React.createElement(FlexItem, null,
-            React.createElement(Button, { onClick: start, variant: "link", isInline: true, "data-testid": "qs-card-notStarted-start", id: `${quickStartId}-start`, "aria-labelledby": `${quickStartId}-start ${quickStartId}` }, getResource('Start')))),
-        status === QuickStartStatus.IN_PROGRESS && activeQuickStartID !== quickStartId && (React.createElement(FlexItem, null,
-            React.createElement(Button, { variant: "link", onClick: onClickContinue, isInline: true, "data-testid": "qs-card-inProgress-resume", id: `${quickStartId}-continue`, "aria-labelledby": `${quickStartId}-continue ${quickStartId}` }, getResource('Continue')))),
-        status === QuickStartStatus.COMPLETE && (React.createElement(FlexItem, null,
-            React.createElement(Button, { onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-complete-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, getResource('Restart')))),
-        status === QuickStartStatus.IN_PROGRESS && (React.createElement(FlexItem, null,
-            React.createElement(Button, { onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-inProgress-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, getResource('Restart'))))));
-};
-
-const QuickStartTileFooterExternal = ({ link, quickStartId, }) => {
+    return (jsxs(Flex, Object.assign({ justifyContent: { default: 'justifyContentSpaceBetween' } }, { children: [status === QuickStartStatus.NOT_STARTED && (jsx(FlexItem, { children: jsx(Button, Object.assign({ onClick: start, variant: "link", isInline: true, "data-testid": "qs-card-notStarted-start", id: `${quickStartId}-start`, "aria-labelledby": `${quickStartId}-start ${quickStartId}` }, { children: getResource('Start') })) })), status === QuickStartStatus.IN_PROGRESS && activeQuickStartID !== quickStartId && (jsx(FlexItem, { children: jsx(Button, Object.assign({ variant: "link", onClick: onClickContinue, isInline: true, "data-testid": "qs-card-inProgress-resume", id: `${quickStartId}-continue`, "aria-labelledby": `${quickStartId}-continue ${quickStartId}` }, { children: getResource('Continue') })) })), status === QuickStartStatus.COMPLETE && (jsx(FlexItem, { children: jsx(Button, Object.assign({ onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-complete-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, { children: getResource('Restart') })) })), status === QuickStartStatus.IN_PROGRESS && (jsx(FlexItem, { children: jsx(Button, Object.assign({ onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-inProgress-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, { children: getResource('Restart') })) }))] })));
+};
+
+const QuickStartTileFooterExternal = ({ link, quickStartId }) => {
     const { href, text } = link;
-    return (React.createElement(Flex, { justifyContent: { default: 'justifyContentSpaceBetween' } },
-        React.createElement(FlexItem, null,
-            React.createElement(Button, { component: "a", href: href, target: "_blank", rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: React.createElement(ExternalLinkAltIcon, null), iconPosition: "right", id: quickStartId, "aria-labelledby": `${quickStartId}-external ${quickStartId}` }, text || href))));
+    return (jsx(Flex, Object.assign({ justifyContent: { default: 'justifyContentSpaceBetween' } }, { children: jsx(FlexItem, { children: jsx(Button, Object.assign({ component: "a", href: href, target: "_blank", rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: jsx(ExternalLinkAltIcon, {}), iconPosition: "right", id: quickStartId, "aria-labelledby": `${quickStartId}-external ${quickStartId}` }, { children: text || href })) }) })));
 };
 
-const QuickStartTileHeader = ({ name, quickStartId, onSelect, }) => (React.createElement(Flex, { flexWrap: { default: 'nowrap' } },
-    React.createElement(Button, { "data-test": "title", id: quickStartId, variant: "link", isInline: true, onClick: onSelect }, name)));
+const QuickStartTileHeader = ({ name, quickStartId, onSelect }) => (jsx(Flex, Object.assign({ flexWrap: { default: 'nowrap' } }, { children: jsx(Button, Object.assign({ "data-test": "title", id: quickStartId, variant: "link", isInline: true, onClick: onSelect }, { children: name })) })));
 
 const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, action, }) => {
     const { metadata: { name: id }, spec: { icon, tasks, displayName, description, durationMinutes, prerequisites, link, type }, } = quickStart;
-    const { setActiveQuickStart, footer, getResource } = React.useContext(QuickStartContext);
+    const { setActiveQuickStart, footer, getResource } = useContext(QuickStartContext);
     const statusColorMap = {
         [QuickStartStatus.COMPLETE]: 'green',
         [QuickStartStatus.IN_PROGRESS]: 'purple',
@@ -1612,11 +1652,10 @@ const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, act
     };
     let quickStartIcon;
     if (typeof icon === 'object') {
-        quickStartIcon = React.createElement(Icon, { size: "2xl" }, icon);
+        quickStartIcon = jsx(Icon, Object.assign({ size: "2xl" }, { children: icon }));
     }
     else {
-        quickStartIcon = (React.createElement(Icon, { size: "2xl" },
-            React.createElement(FallbackImg, { src: icon, alt: "", className: "pfext-catalog-item-icon__img", fallback: React.createElement(RocketIcon, null) })));
+        quickStartIcon = (jsx(Icon, Object.assign({ size: "2xl" }, { children: jsx(FallbackImg, { src: icon, alt: "", className: "pfext-catalog-item-icon__img", fallback: jsx(RocketIcon, {}) }) })));
     }
     const onSelect = () => {
         if (!link) {
@@ -1627,70 +1666,53 @@ const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, act
         }
         onClick();
     };
-    const footerComponent = React.useMemo(() => {
+    const footerComponent = useMemo(() => {
         if (footer && footer.show === false) {
             return null;
         }
         if (link) {
-            return React.createElement(QuickStartTileFooterExternal, { link: link, quickStartId: id });
+            return jsx(QuickStartTileFooterExternal, { link: link, quickStartId: id });
         }
-        return (React.createElement(QuickStartTileFooter, { quickStartId: id, status: status, totalTasks: tasks === null || tasks === void 0 ? void 0 : tasks.length, onClickContinue: onSelect }));
+        return (jsx(QuickStartTileFooter, { quickStartId: id, status: status, totalTasks: tasks === null || tasks === void 0 ? void 0 : tasks.length, onClickContinue: onSelect }));
     }, [footer, id, link, status, tasks === null || tasks === void 0 ? void 0 : tasks.length]);
     const ActionIcon = (action === null || action === void 0 ? void 0 : action.icon) || OutlinedBookmarkIcon;
-    const additionalAction = action ? (React.createElement(Button, Object.assign({ "aria-label": action['aria-label'], icon: React.createElement(ActionIcon, null), variant: "plain", onClick: action.onClick }, action.buttonProps))) : undefined;
-    return (React.createElement(Card, Object.assign({ id: `${id}-catalog-tile`, style: { height: '100%' }, "data-testid": `qs-card-${camelize(displayName)}`, className: "pfext-catalog-item" }, (isActive && {
+    const additionalAction = action ? (jsx(Button, Object.assign({ "aria-label": action['aria-label'], icon: jsx(ActionIcon, {}), variant: "plain", onClick: action.onClick }, action.buttonProps))) : undefined;
+    return (jsxs(Card, Object.assign({ id: `${id}-catalog-tile`, style: { height: '100%' }, "data-testid": `qs-card-${camelize(displayName)}`, className: "pfext-catalog-item" }, (isActive && {
         isClickable: true,
         isSelectable: true,
         isSelected: true,
         isClicked: true,
-    })),
-        React.createElement(CardHeader, Object.assign({}, (action && {
-            actions: { actions: additionalAction },
-        })), quickStartIcon),
-        React.createElement(CardTitle, null,
-            React.createElement(QuickStartTileHeader, { name: displayName, onSelect: onSelect, quickStartId: id })),
-        React.createElement(CardBody, null,
-            React.createElement(Stack, { hasGutter: true },
-                React.createElement(Flex, { spaceItems: { default: 'spaceItemsSm' } },
-                    type && React.createElement(Label, { color: type.color }, type.text),
-                    durationMinutes && (React.createElement(Label, { variant: "outline", "data-test": "duration", icon: React.createElement(OutlinedClockIcon, null) }, getResource('{{duration, number}} minutes', durationMinutes).replace('{{duration, number}}', durationMinutes))),
-                    status !== QuickStartStatus.NOT_STARTED && (React.createElement(Label, { variant: "outline", color: statusColorMap[status], icon: React.createElement(StatusIcon, { status: status }), "data-test": "status" }, statusLocaleMap[status]))),
-                React.createElement(QuickStartTileDescription, { description: description, prerequisites: prerequisites }))),
-        React.createElement(CardFooter, null, footerComponent)));
+    }), { children: [jsx(CardHeader, Object.assign({}, (action && {
+                actions: { actions: additionalAction },
+            }), { children: quickStartIcon })), jsx(CardTitle, { children: jsx(QuickStartTileHeader, { name: displayName, onSelect: onSelect, quickStartId: id }) }), jsx(CardBody, { children: jsxs(Stack, Object.assign({ hasGutter: true }, { children: [jsxs(Flex, Object.assign({ spaceItems: { default: 'spaceItemsSm' } }, { children: [type && jsx(Label, Object.assign({ color: type.color }, { children: type.text })), durationMinutes && (jsx(Label, Object.assign({ variant: "outline", "data-test": "duration", icon: jsx(OutlinedClockIcon, {}) }, { children: getResource('{{duration, number}} minutes', durationMinutes).replace('{{duration, number}}', durationMinutes) }))), status !== QuickStartStatus.NOT_STARTED && (jsx(Label, Object.assign({ variant: "outline", color: statusColorMap[status], icon: jsx(StatusIcon, { status: status }), "data-test": "status" }, { children: statusLocaleMap[status] })))] })), jsx(QuickStartTileDescription, { description: description, prerequisites: prerequisites })] })) }), jsx(CardFooter, { children: footerComponent })] })));
 };
 
 const QuickStartCatalog = ({ quickStarts }) => {
-    const { activeQuickStartID, allQuickStartStates } = React.useContext(QuickStartContext);
-    return (React.createElement("div", null,
-        React.createElement(Gallery, { hasGutter: true, className: "pfext-quick-start-catalog__gallery" }, quickStarts.map((quickStart, index) => {
-            const { metadata: { name: id }, } = quickStart;
-            return (React.createElement(QuickStartTile, { key: index, quickStart: quickStart, isActive: id === activeQuickStartID, status: getQuickStartStatus(allQuickStartStates, id) }));
-        }))));
+    const { activeQuickStartID, allQuickStartStates } = useContext(QuickStartContext);
+    return (jsx("div", { children: jsx(Gallery, Object.assign({ hasGutter: true, className: "pfext-quick-start-catalog__gallery" }, { children: quickStarts.map((quickStart, index) => {
+                const { metadata: { name: id }, } = quickStart;
+                return (jsx(QuickStartTile, { quickStart: quickStart, isActive: id === activeQuickStartID, status: getQuickStartStatus(allQuickStartStates, id) }, index));
+            }) })) }));
 };
 
 const QuickStartCatalogFilterSearch = (_a) => {
     var { searchInputText, handleTextChange } = _a, props = __rest(_a, ["searchInputText", "handleTextChange"]);
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(ToolbarItem, null,
-        React.createElement(SearchInput, Object.assign({ placeholder: getResource('Filter by keyword...'), value: searchInputText, onChange: (_ev, value) => handleTextChange(value), onClear: () => handleTextChange('') }, props))));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsx(ToolbarItem, { children: jsx(SearchInput, Object.assign({ placeholder: getResource('Filter by keyword...'), value: searchInputText, onChange: (_ev, value) => handleTextChange(value), onClear: () => handleTextChange('') }, props)) }));
 };
 const QuickStartCatalogFilterSelect = (_a) => {
     var { isDropdownOpen, setIsDropdownOpen, onRowfilterSelect, selectedFilters, dropdownItems } = _a, props = __rest(_a, ["isDropdownOpen", "setIsDropdownOpen", "onRowfilterSelect", "selectedFilters", "dropdownItems"]);
-    const { getResource } = React.useContext(QuickStartContext);
-    const toggle = (toggleRef) => (React.createElement(MenuToggle, { isFullWidth: true, ref: toggleRef, onClick: () => setIsDropdownOpen(!isDropdownOpen), isExpanded: isDropdownOpen },
-        getResource('Status'),
-        selectedFilters.length > 0 && React.createElement(Badge, { isRead: true }, selectedFilters.length)));
-    return (React.createElement(ToolbarItem, null,
-        React.createElement(Select, Object.assign({ "aria-label": getResource('Select filter'), isOpen: isDropdownOpen, selected: selectedFilters, onSelect: onRowfilterSelect, onOpenChange: (isOpen) => setIsDropdownOpen(isOpen), toggle: toggle }, props),
-            React.createElement(SelectList, null, dropdownItems))));
+    const { getResource } = useContext(QuickStartContext);
+    const toggle = (toggleRef) => (jsxs(MenuToggle, Object.assign({ isFullWidth: true, ref: toggleRef, onClick: () => setIsDropdownOpen(!isDropdownOpen), isExpanded: isDropdownOpen }, { children: [getResource('Status'), selectedFilters.length > 0 && jsx(Badge, Object.assign({ isRead: true }, { children: selectedFilters.length }))] })));
+    return (jsx(ToolbarItem, { children: jsx(Select, Object.assign({ "aria-label": getResource('Select filter'), isOpen: isDropdownOpen, selected: selectedFilters, onSelect: onRowfilterSelect, onOpenChange: (isOpen) => setIsDropdownOpen(isOpen), toggle: toggle }, props, { children: jsx(SelectList, { children: dropdownItems }) })) }));
 };
 const QuickStartCatalogFilterCount = ({ quickStartsCount }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(ToolbarItem, { align: { default: 'alignEnd' } }, getResource('{{count, number}} item', quickStartsCount).replace('{{count, number}}', quickStartsCount)));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsx(ToolbarItem, Object.assign({ align: { default: 'alignEnd' } }, { children: getResource("{{count, number}} item", quickStartsCount).replace('{{count, number}}', quickStartsCount) })));
 };
 const QuickStartCatalogFilterSearchWrapper = ({ onSearchInputChange = () => { } }) => {
-    const { useQueryParams, filter, setFilter } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const { useQueryParams, filter, setFilter } = useContext(QuickStartContext);
+    useEffect(() => {
         //   use this effect to clear the search when a `clear all` action is performed higher up
         const unlisten = history.listen(({ location }) => {
             const searchParams = new URLSearchParams(location.search);
@@ -1716,7 +1738,7 @@ const QuickStartCatalogFilterSearchWrapper = ({ onSearchInputChange = () => { }
         }
         onSearchInputChange(val);
     };
-    return (React.createElement(QuickStartCatalogFilterSearch, { searchInputText: filter === null || filter === void 0 ? void 0 : filter.keyword, handleTextChange: handleTextChange }));
+    return (jsx(QuickStartCatalogFilterSearch, { searchInputText: filter === null || filter === void 0 ? void 0 : filter.keyword, handleTextChange: handleTextChange }));
 };
 // compare string/number arrays
 const equalsIgnoreOrder = (a, b) => {
@@ -1734,8 +1756,8 @@ const equalsIgnoreOrder = (a, b) => {
     return true;
 };
 const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) => {
-    const { useQueryParams, filter, setFilter } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const { useQueryParams, filter, setFilter } = useContext(QuickStartContext);
+    useEffect(() => {
         //   use this effect to clear the status when a `clear all` action is performed higher up
         const unlisten = history.listen(({ location }) => {
             var _a;
@@ -1750,8 +1772,8 @@ const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) =>
             unlisten();
         };
     });
-    const [isDropdownOpen, setIsDropdownOpen] = React.useState(false);
-    const onRowfilterSelect = React.useCallback((_e, selectedValue) => {
+    const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+    const onRowfilterSelect = useCallback((_e, selectedValue) => {
         setIsDropdownOpen(false);
         const selection = Object.entries(filter.status.statusTypes).find(([_key, value]) => value === selectedValue)[0];
         const selectedFiltersList = filter.status.statusFilters.includes(selection)
@@ -1768,33 +1790,24 @@ const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) =>
         }
         onStatusChange(selectedFiltersList);
     }, [filter.status.statusFilters, onStatusChange, setFilter, useQueryParams]);
-    const dropdownItems = Object.entries(filter.status.statusTypes).map(([key, value]) => (React.createElement(SelectOption, { key: key, "data-key": key, value: value, hasCheckbox: true, isSelected: filter.status.statusFilters.includes(key) },
-        React.createElement(React.Fragment, null, value))));
-    return (React.createElement(QuickStartCatalogFilterSelect, { isDropdownOpen: isDropdownOpen, setIsDropdownOpen: setIsDropdownOpen, onRowfilterSelect: onRowfilterSelect, selectedFilters: filter.status.statusFilters, dropdownItems: dropdownItems }));
+    const dropdownItems = Object.entries(filter.status.statusTypes).map(([key, value]) => (jsx(SelectOption, Object.assign({ "data-key": key, value: value, hasCheckbox: true, isSelected: filter.status.statusFilters.includes(key) }, { children: jsx(Fragment$1, { children: value }) }), key)));
+    return (jsx(QuickStartCatalogFilterSelect, { isDropdownOpen: isDropdownOpen, setIsDropdownOpen: setIsDropdownOpen, onRowfilterSelect: onRowfilterSelect, selectedFilters: filter.status.statusFilters, dropdownItems: dropdownItems }));
 };
-const QuickStartCatalogFilterCountWrapper = ({ quickStartsCount }) => React.createElement(QuickStartCatalogFilterCount, { quickStartsCount: quickStartsCount });
+const QuickStartCatalogFilterCountWrapper = ({ quickStartsCount, }) => jsx(QuickStartCatalogFilterCount, { quickStartsCount: quickStartsCount });
 
 const QuickStartCatalogFilter = (_a) => {
     var { quickStartsCount, onSearchInputChange = () => { }, onStatusChange = () => { } } = _a, props = __rest(_a, ["quickStartsCount", "onSearchInputChange", "onStatusChange"]);
-    return (React.createElement(Toolbar, Object.assign({}, props),
-        React.createElement(ToolbarContent, null,
-            React.createElement(QuickStartCatalogFilterSearchWrapper, { onSearchInputChange: onSearchInputChange }),
-            React.createElement(QuickStartCatalogFilterStatusWrapper, { onStatusChange: onStatusChange }),
-            React.createElement(QuickStartCatalogFilterCountWrapper, { quickStartsCount: quickStartsCount }))));
+    return (jsx(Toolbar, Object.assign({}, props, { children: jsxs(ToolbarContent, { children: [jsx(QuickStartCatalogFilterSearchWrapper, { onSearchInputChange: onSearchInputChange }), jsx(QuickStartCatalogFilterStatusWrapper, { onStatusChange: onStatusChange }), jsx(QuickStartCatalogFilterCountWrapper, { quickStartsCount: quickStartsCount })] }) })));
 };
 
 const QuickStartCatalogEmptyState = ({ clearFilters }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(EmptyState, { headingLevel: "h4", icon: SearchIcon, titleText: React.createElement(React.Fragment, null, getResource('No results found')) },
-        React.createElement(EmptyStateBody, null, getResource('No results match the filter criteria. Remove filters or clear all filters to show results.')),
-        React.createElement(EmptyStateFooter, null,
-            React.createElement(EmptyStateActions, null,
-                React.createElement(Button, { variant: "link", onClick: clearFilters, "data-test": "clear-filter button" }, getResource('Clear all filters'))))));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxs(EmptyState, Object.assign({ headingLevel: "h4", icon: SearchIcon, titleText: jsx(Fragment$1, { children: getResource('No results found') }) }, { children: [jsx(EmptyStateBody, { children: getResource('No results match the filter criteria. Remove filters or clear all filters to show results.') }), jsx(EmptyStateFooter, { children: jsx(EmptyStateActions, { children: jsx(Button, Object.assign({ variant: "link", onClick: clearFilters, "data-test": "clear-filter button" }, { children: getResource('Clear all filters') })) }) })] })));
 };
 const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) => q1.spec.displayName.localeCompare(q2.spec.displayName), title, hint, showTitle = true, }) => {
-    const sortFncCallback = React.useCallback(sortFnc, [sortFnc]);
-    const { allQuickStarts = [], setAllQuickStarts, allQuickStartStates, getResource, filter, setFilter, loading, } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const sortFncCallback = useCallback(sortFnc, [sortFnc]);
+    const { allQuickStarts = [], setAllQuickStarts, allQuickStartStates, getResource, filter, setFilter, loading, } = useContext(QuickStartContext);
+    useEffect(() => {
         // passed through prop, not context
         if (quickStarts && JSON.stringify(quickStarts) !== JSON.stringify(allQuickStarts)) {
             setAllQuickStarts(quickStarts);
@@ -1803,8 +1816,8 @@ const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) =>
     const initialFilteredQuickStarts = showFilter
         ? filterQuickStarts(allQuickStarts, filter.keyword, filter.status.statusFilters, allQuickStartStates).sort(sortFncCallback)
         : allQuickStarts;
-    const [filteredQuickStarts, setFilteredQuickStarts] = React.useState(initialFilteredQuickStarts);
-    React.useEffect(() => {
+    const [filteredQuickStarts, setFilteredQuickStarts] = useState(initialFilteredQuickStarts);
+    useEffect(() => {
         const filteredQs = showFilter
             ? filterQuickStarts(allQuickStarts, filter.keyword, filter.status.statusFilters, allQuickStartStates).sort(sortFncCallback)
             : allQuickStarts;
@@ -1847,59 +1860,37 @@ const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) =>
         }
     };
     if (loading) {
-        return React.createElement(LoadingBox, null);
+        return jsx(LoadingBox, {});
     }
     if (!allQuickStarts || allQuickStarts.length === 0) {
-        return React.createElement(EmptyBox, { label: getResource('Quick Starts') });
+        return jsx(EmptyBox, { label: getResource('Quick Starts') });
     }
-    return (React.createElement(React.Fragment, null,
-        (showTitle || showFilter) && (React.createElement(PageSection, { hasBodyWrapper: false },
-            showTitle && (React.createElement(Content, { isEditorial: true },
-                React.createElement(Title, { headingLevel: "h1", "data-test": "page-title" }, title || getResource('Quick Starts')),
-                hint && React.createElement("div", null, hint))),
-            showTitle && React.createElement(Divider, { component: "div" }),
-            showFilter && (React.createElement(React.Fragment, null,
-                React.createElement(QuickStartCatalogFilter, { quickStartsCount: filteredQuickStarts.length, onSearchInputChange: onSearchInputChange, onStatusChange: onStatusChange }))))),
-        React.createElement(PageSection, { hasBodyWrapper: false }, filteredQuickStarts.length === 0 ? (React.createElement(QuickStartCatalogEmptyState, { clearFilters: clearFilters })) : (React.createElement(QuickStartCatalog, { quickStarts: filteredQuickStarts })))));
+    return (jsxs(Fragment$1, { children: [(showTitle || showFilter) && (jsxs(PageSection, Object.assign({ hasBodyWrapper: false }, { children: [showTitle && (jsxs(Content, Object.assign({ isEditorial: true }, { children: [jsx(Title, Object.assign({ headingLevel: "h1", "data-test": "page-title" }, { children: title || getResource('Quick Starts') })), hint && jsx("div", { children: hint })] }))), showTitle && jsx(Divider, { component: "div" }), showFilter && (jsx(Fragment$1, { children: jsx(QuickStartCatalogFilter, { quickStartsCount: filteredQuickStarts.length, onSearchInputChange: onSearchInputChange, onStatusChange: onStatusChange }) }))] }))), jsx(PageSection, Object.assign({ hasBodyWrapper: false }, { children: filteredQuickStarts.length === 0 ? (jsx(QuickStartCatalogEmptyState, { clearFilters: clearFilters })) : (jsx(QuickStartCatalog, { quickStarts: filteredQuickStarts })) }))] }));
 };
 
-const QuickStartCatalogHeader = ({ title, hint, }) => (React.createElement("div", null,
-    React.createElement(Title, { headingLevel: "h1", "data-pf-content": "true" }, title),
-    hint && React.createElement("div", null, hint)));
+const QuickStartCatalogHeader = ({ title, hint, }) => (jsxs("div", { children: [jsx(Title, Object.assign({ headingLevel: "h1", "data-pf-content": "true" }, { children: title })), hint && jsx("div", { children: hint })] }));
 
-const QuickStartCatalogSection = ({ children }) => (React.createElement("div", null, children));
+const QuickStartCatalogSection = ({ children }) => (jsx("div", { children: children }));
 
-const QuickStartCatalogToolbar = ({ children }) => (React.createElement(Toolbar, null, children));
+const QuickStartCatalogToolbar = ({ children }) => (jsx(Toolbar, { children: children }));
 
-const QuickStartCloseModal = ({ isOpen, onConfirm, onCancel, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(Modal, { isOpen: isOpen, variant: ModalVariant.small, showClose: false, "data-test": "leave-quickstart", title: getResource('Leave quick start?'), footer: React.createElement(Flex, null,
-            React.createElement(FlexItem, { align: { default: 'alignRight' } },
-                React.createElement(Button, { variant: "secondary", "data-test": "cancel button", onClick: onCancel }, getResource('Cancel'))),
-            React.createElement(FlexItem, null,
-                React.createElement(Button, { variant: "primary", "data-test": "leave button", onClick: onConfirm }, getResource('Leave')))), isFullScreen: true }, getResource('Your progress will be saved.')));
+const QuickStartCloseModal = ({ isOpen, onConfirm, onCancel }) => {
+    const { getResource } = useContext(QuickStartContext);
+    return (jsx(Modal, Object.assign({ isOpen: isOpen, variant: ModalVariant.small, showClose: false, "data-test": "leave-quickstart", title: getResource('Leave quick start?'), footer: jsxs(Flex, { children: [jsx(FlexItem, Object.assign({ align: { default: 'alignRight' } }, { children: jsx(Button, Object.assign({ variant: "secondary", "data-test": "cancel button", onClick: onCancel }, { children: getResource('Cancel') })) })), jsx(FlexItem, { children: jsx(Button, Object.assign({ variant: "primary", "data-test": "leave button", onClick: onConfirm }, { children: getResource('Leave') })) })] }), isFullScreen: true }, { children: getResource('Your progress will be saved.') })));
 };
 
 const QuickStartTaskHeader = ({ title, taskIndex, subtitle, taskStatus, size, isActiveTask, onTaskSelect, children, }) => {
-    const titleRef = React.useRef(null);
-    const { focusOnQuickStart } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const titleRef = useRef(null);
+    const { focusOnQuickStart } = useContext(QuickStartContext);
+    useEffect(() => {
         if (focusOnQuickStart && isActiveTask) {
             // Focus the WizardNavItem button element that contains the title
             titleRef.current.parentNode.focus();
         }
     }, [focusOnQuickStart, isActiveTask]);
     const failedReview = taskStatus === QuickStartTaskStatus.FAILED;
-    const tryAgain = failedReview && (React.createElement(React.Fragment, null,
-        React.createElement("div", null),
-        React.createElement("div", { className: "pfext-quick-start-task-header__tryagain" }, "Try the steps again.")));
-    const content = (React.createElement("div", { ref: titleRef },
-        React.createElement(Title, { headingLevel: "h3", size: size },
-            React.createElement("span", { className: "pfext-quick-start-task-header__title" }, title),
-            isActiveTask && subtitle && (React.createElement("span", null,
-                ' ',
-                React.createElement("span", { "data-test-id": "quick-start-task-subtitle", className: "pfext-quick-start-task-header__subtitle" }, subtitle))),
-            tryAgain)));
+    const tryAgain = failedReview && (jsxs(Fragment$1, { children: [jsx("div", {}), jsx("div", Object.assign({ className: "pfext-quick-start-task-header__tryagain" }, { children: "Try the steps again." }))] }));
+    const content = (jsx("div", Object.assign({ ref: titleRef }, { children: jsxs(Title, Object.assign({ headingLevel: "h3", size: size }, { children: [jsx("span", Object.assign({ className: "pfext-quick-start-task-header__title" }, { children: title })), isActiveTask && subtitle && (jsxs("span", { children: [' ', jsx("span", Object.assign({ "data-test-id": "quick-start-task-subtitle", className: "pfext-quick-start-task-header__subtitle" }, { children: subtitle }))] })), tryAgain] })) })));
     let status = 'default';
     if (taskStatus === QuickStartTaskStatus.FAILED) {
         status = 'error';
@@ -1907,42 +1898,31 @@ const QuickStartTaskHeader = ({ title, taskIndex, subtitle, taskStatus, size, is
     else if (taskStatus === QuickStartTaskStatus.SUCCESS) {
         status = 'success';
     }
-    return (React.createElement(WizardNavItem, { content: content, stepIndex: taskIndex, onClick: () => onTaskSelect(taskIndex - 1), component: "button", isCurrent: isActiveTask, status: status, className: "pfext-quick-start-task-header" }, children));
+    return (jsx(WizardNavItem, Object.assign({ content: content, stepIndex: taskIndex, onClick: () => onTaskSelect(taskIndex - 1), component: "button", isCurrent: isActiveTask, status: status, className: "pfext-quick-start-task-header" }, { children: children })));
 };
 
-const QuickStartTaskHeaderList = ({ tasks, allTaskStatuses, onTaskSelect, }) => (tasks === null || tasks === void 0 ? void 0 : tasks.length) > 0 ? (React.createElement("ul", { className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list" }, tasks.map((task, index) => (React.createElement(QuickStartTaskHeader, { key: task.title, title: task.title, taskIndex: index + 1, size: "md", taskStatus: allTaskStatuses[index], onTaskSelect: onTaskSelect }))))) : null;
+const QuickStartTaskHeaderList = ({ tasks, allTaskStatuses, onTaskSelect, }) => (tasks === null || tasks === void 0 ? void 0 : tasks.length) > 0 ? (jsx("ul", Object.assign({ className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list" }, { children: tasks.map((task, index) => (jsx(QuickStartTaskHeader, { title: task.title, taskIndex: index + 1, size: "md", taskStatus: allTaskStatuses[index], onTaskSelect: onTaskSelect }, task.title))) }))) : null;
 
 const QuickStartConclusion = ({ tasks, conclusion, allTaskStatuses, nextQuickStarts, onQuickStartChange, onTaskSelect, }) => {
     const hasFailedTask = allTaskStatuses.includes(QuickStartTaskStatus.FAILED);
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect }),
-        React.createElement(QuickStartMarkdownView, { content: hasFailedTask
-                ? getResource('One or more verifications did not pass during this quick start. Revisit the tasks or the help links, and then try again.')
-                : conclusion }),
-        !hasFailedTask &&
-            nextQuickStarts &&
-            nextQuickStarts.length > 0 &&
-            nextQuickStarts.map((nextQuickStart, index) => {
-                var _a;
-                return (React.createElement(Button, { variant: "link", onClick: () => onQuickStartChange(nextQuickStart.metadata.name), isInline: true, icon: React.createElement(ArrowRightIcon, null), iconPosition: "end", isBlock: true, key: index, style: { marginTop: 'var(--pf-t--global--spacer--md' } }, getResource('Start {{nextQSDisplayName}} quick start').replace('{{nextQSDisplayName}}', (_a = nextQuickStart === null || nextQuickStart === void 0 ? void 0 : nextQuickStart.spec) === null || _a === void 0 ? void 0 : _a.displayName)));
-            })));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxs(Fragment$1, { children: [jsx(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect }), jsx(QuickStartMarkdownView, { content: hasFailedTask
+                    ? getResource('One or more verifications did not pass during this quick start. Revisit the tasks or the help links, and then try again.')
+                    : conclusion }), !hasFailedTask &&
+                nextQuickStarts &&
+                nextQuickStarts.length > 0 &&
+                nextQuickStarts.map((nextQuickStart, index) => {
+                    var _a;
+                    return (jsx(Button, Object.assign({ variant: "link", onClick: () => onQuickStartChange(nextQuickStart.metadata.name), isInline: true, icon: jsx(ArrowRightIcon, {}), iconPosition: "end", isBlock: true, style: { marginTop: 'var(--pf-t--global--spacer--md' } }, { children: getResource('Start {{nextQSDisplayName}} quick start').replace('{{nextQSDisplayName}}', (_a = nextQuickStart === null || nextQuickStart === void 0 ? void 0 : nextQuickStart.spec) === null || _a === void 0 ? void 0 : _a.displayName) }), index));
+                })] }));
 };
 
 const QuickStartIntroduction = ({ tasks, introduction, allTaskStatuses, prerequisites, onTaskSelect, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
+    const { getResource } = useContext(QuickStartContext);
     const prereqs = prerequisites === null || prerequisites === void 0 ? void 0 : prerequisites.filter((p) => p);
-    const [isPrereqsExpanded, setIsPrereqsExpanded] = React.useState(false);
-    const prereqList = (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (React.createElement(ExpandableSection, { toggleText: getResource('View Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), onToggle: () => setIsPrereqsExpanded(!isPrereqsExpanded) },
-        React.createElement(List, null, prereqs.map((pr) => (React.createElement(ListItem, { key: pr },
-            React.createElement(QuickStartMarkdownView, { content: pr })))))));
-    return (React.createElement(Stack, { hasGutter: true },
-        React.createElement(QuickStartMarkdownView, { content: introduction }),
-        prereqList,
-        React.createElement("p", null,
-            getResource('In this quick start, you will complete {{count, number}} task', tasks === null || tasks === void 0 ? void 0 : tasks.length).replace('{{count, number}}', (tasks === null || tasks === void 0 ? void 0 : tasks.length) || 0),
-            ":"),
-        React.createElement(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect })));
+    const [isPrereqsExpanded, setIsPrereqsExpanded] = useState(false);
+    const prereqList = (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (jsx(ExpandableSection, Object.assign({ toggleText: getResource('View Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), onToggle: () => setIsPrereqsExpanded(!isPrereqsExpanded) }, { children: jsx(List, { children: prereqs.map((pr) => (jsx(ListItem, { children: jsx(QuickStartMarkdownView, { content: pr }) }, pr))) }) })));
+    return (jsxs(Stack, Object.assign({ hasGutter: true }, { children: [jsx(QuickStartMarkdownView, { content: introduction }), prereqList, jsxs("p", { children: [getResource('In this quick start, you will complete {{count, number}} task', (tasks === null || tasks === void 0 ? void 0 : tasks.length) || 0).replace('{{count, number}}', (tasks === null || tasks === void 0 ? void 0 : tasks.length) || 0), ":"] }), jsx(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect })] })));
 };
 
 const getAlertVariant = (status) => {
@@ -1957,64 +1937,52 @@ const getAlertVariant = (status) => {
 };
 const QuickStartTaskReview = ({ review, taskStatus, onTaskReview, }) => {
     const { instructions, failedTaskHelp: taskHelp } = review;
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(Alert, { variant: getAlertVariant(taskStatus), title: getResource('Check your work'), isInline: true, role: "alert", style: {
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxs(Alert, Object.assign({ variant: getAlertVariant(taskStatus), title: getResource('Check your work'), isInline: true, role: "alert", style: {
             marginBottom: 'var(--pf-t--global--spacer--md)',
-        } },
-        React.createElement(QuickStartMarkdownView, { content: instructions }),
-        React.createElement("span", { className: "pfext-quick-start-task-review__actions" },
-            React.createElement(Radio, { id: "review-success", name: "review-success", "data-testid": "qs-drawer-check-yes", label: getResource('Yes'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.SUCCESS, onChange: () => onTaskReview(QuickStartTaskStatus.SUCCESS) }),
-            React.createElement(Radio, { id: "review-failed", name: "review-failed", "data-testid": "qs-drawer-check-no", label: getResource('No'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.FAILED, onChange: () => onTaskReview(QuickStartTaskStatus.FAILED) })),
-        taskStatus === QuickStartTaskStatus.FAILED && taskHelp && (React.createElement(QuickStartMarkdownView, { content: taskHelp, exactHeight: true }))));
+        } }, { children: [jsx(QuickStartMarkdownView, { content: instructions }), jsxs("span", Object.assign({ className: "pfext-quick-start-task-review__actions" }, { children: [jsx(Radio, { id: "review-success", name: "review-success", "data-testid": "qs-drawer-check-yes", label: getResource('Yes'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.SUCCESS, onChange: () => onTaskReview(QuickStartTaskStatus.SUCCESS) }), jsx(Radio, { id: "review-failed", name: "review-failed", "data-testid": "qs-drawer-check-no", label: getResource('No'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.FAILED, onChange: () => onTaskReview(QuickStartTaskStatus.FAILED) })] })), taskStatus === QuickStartTaskStatus.FAILED && taskHelp && (jsx(QuickStartMarkdownView, { content: taskHelp, exactHeight: true }))] })));
 };
 
 const QuickStartTasks = ({ tasks, taskNumber, allTaskStatuses, onTaskReview, onTaskSelect, }) => {
-    const { getResource, alwaysShowTaskReview } = React.useContext(QuickStartContext);
-    return (React.createElement("div", { className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list", style: { padding: '0 0 0 0' } },
-        React.createElement("ul", null, tasks
-            .filter((_, index) => allTaskStatuses[index] !== QuickStartTaskStatus.INIT)
-            .map((task, index) => {
-            const { title, description, review } = task;
-            const isActiveTask = index === taskNumber;
-            const taskStatus = allTaskStatuses[index];
-            const shouldShowTaskReview = (!QUICKSTART_TASKS_INITIAL_STATES.includes(taskStatus) || alwaysShowTaskReview) &&
-                review;
-            return (React.createElement(React.Fragment, { key: title },
-                React.createElement(QuickStartTaskHeader, { taskIndex: index + 1, title: title, size: "md", subtitle: getResource('{{index, number}} of {{tasks, number}}')
-                        .replace('{{index, number}}', index + 1)
-                        .replace('{{tasks, number}}', tasks.length), taskStatus: taskStatus, isActiveTask: isActiveTask, onTaskSelect: onTaskSelect }, isActiveTask && (React.createElement(Stack, { hasGutter: true },
-                    React.createElement(QuickStartMarkdownView, { content: description }),
-                    shouldShowTaskReview && (React.createElement(QuickStartTaskReview, { review: review, taskStatus: taskStatus, onTaskReview: onTaskReview })))))));
-        }))));
-};
-
-const QuickStartContent = React.forwardRef(({ quickStart, nextQuickStarts = [], taskNumber, allTaskStatuses, onTaskSelect, onTaskReview, onQuickStartChange, }, ref) => {
+    const { getResource, alwaysShowTaskReview } = useContext(QuickStartContext);
+    return (jsx("div", Object.assign({ className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list", style: { padding: '0 0 0 0' } }, { children: jsx("ul", { children: tasks
+                .filter((_, index) => allTaskStatuses[index] !== QuickStartTaskStatus.INIT)
+                .map((task, index) => {
+                const { title, description, review } = task;
+                const isActiveTask = index === taskNumber;
+                const taskStatus = allTaskStatuses[index];
+                const shouldShowTaskReview = (!QUICKSTART_TASKS_INITIAL_STATES.includes(taskStatus) || alwaysShowTaskReview) &&
+                    review;
+                return (jsx(Fragment, { children: jsx(QuickStartTaskHeader, Object.assign({ taskIndex: index + 1, title: title, size: "md", subtitle: getResource('{{index, number}} of {{tasks, number}}')
+                            .replace('{{index, number}}', index + 1)
+                            .replace('{{tasks, number}}', tasks.length), taskStatus: taskStatus, isActiveTask: isActiveTask, onTaskSelect: onTaskSelect }, { children: isActiveTask && (jsxs(Stack, Object.assign({ hasGutter: true }, { children: [jsx(QuickStartMarkdownView, { content: description }), shouldShowTaskReview && (jsx(QuickStartTaskReview, { review: review, taskStatus: taskStatus, onTaskReview: onTaskReview }))] }))) })) }, title));
+            }) }) })));
+};
+
+const QuickStartContent = forwardRef(({ quickStart, nextQuickStarts = [], taskNumber, allTaskStatuses, onTaskSelect, onTaskReview, onQuickStartChange, }, ref) => {
     const { spec: { introduction, tasks, conclusion, prerequisites }, } = quickStart;
     const totalTasks = tasks === null || tasks === void 0 ? void 0 : tasks.length;
-    return (React.createElement("div", { className: "pfext-quick-start-task", ref: ref },
-        taskNumber === -1 && (React.createElement(QuickStartIntroduction, { tasks: tasks, allTaskStatuses: allTaskStatuses, introduction: introduction, prerequisites: prerequisites, onTaskSelect: onTaskSelect })),
-        taskNumber > -1 && taskNumber < totalTasks && (React.createElement(QuickStartTasks, { tasks: tasks, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskReview: onTaskReview, onTaskSelect: onTaskSelect })),
-        taskNumber === totalTasks && (React.createElement(QuickStartConclusion, { tasks: tasks, conclusion: conclusion, allTaskStatuses: allTaskStatuses, nextQuickStarts: nextQuickStarts, onQuickStartChange: onQuickStartChange, onTaskSelect: onTaskSelect }))));
+    return (jsxs("div", Object.assign({ className: "pfext-quick-start-task", ref: ref }, { children: [taskNumber === -1 && (jsx(QuickStartIntroduction, { tasks: tasks, allTaskStatuses: allTaskStatuses, introduction: introduction, prerequisites: prerequisites, onTaskSelect: onTaskSelect })), taskNumber > -1 && taskNumber < totalTasks && (jsx(QuickStartTasks, { tasks: tasks, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskReview: onTaskReview, onTaskSelect: onTaskSelect })), taskNumber === totalTasks && (jsx(QuickStartConclusion, { tasks: tasks, conclusion: conclusion, allTaskStatuses: allTaskStatuses, nextQuickStarts: nextQuickStarts, onQuickStartChange: onQuickStartChange, onTaskSelect: onTaskSelect }))] })));
 });
 
 const QuickStartFooter = ({ status, taskNumber, totalTasks, onNext, onBack, quickStartId, className, }) => {
-    const { restartQuickStart, getResource } = React.useContext(QuickStartContext);
-    const PrimaryButtonText = React.useMemo(() => ({
+    const { restartQuickStart, getResource } = useContext(QuickStartContext);
+    const PrimaryButtonText = useMemo(() => ({
         START: getResource('Start'),
         CONTINUE: getResource('Continue'),
         NEXT: getResource('Next'),
         CLOSE: getResource('Close'),
     }), [getResource]);
-    const SecondaryButtonText = React.useMemo(() => ({
+    const SecondaryButtonText = useMemo(() => ({
         BACK: getResource('Back'),
         RESTART: getResource('Restart'),
     }), [getResource]);
-    const onRestart = React.useCallback((e) => {
+    const onRestart = useCallback((e) => {
         e.preventDefault();
         e.stopPropagation();
         restartQuickStart(quickStartId, totalTasks);
     }, [quickStartId, restartQuickStart, totalTasks]);
-    const getPrimaryButtonText = React.useMemo(() => {
+    const getPrimaryButtonText = useMemo(() => {
         if (status === QuickStartStatus.NOT_STARTED) {
             return PrimaryButtonText.START;
         }
@@ -2026,23 +1994,17 @@ const QuickStartFooter = ({ status, taskNumber, totalTasks, onNext, onBack, quic
         }
         return PrimaryButtonText.CONTINUE;
     }, [taskNumber, totalTasks, PrimaryButtonText, status]);
-    const getPrimaryButton = React.useMemo(() => (React.createElement(Button, { variant: "primary", className: "pfext-quick-start-footer__actionbtn", onClick: onNext, "data-testid": `qs-drawer-${camelize(getPrimaryButtonText)}`, "data-test": `${getPrimaryButtonText} button` }, getPrimaryButtonText)), [getPrimaryButtonText, onNext]);
-    const getSecondaryButton = React.useMemo(() => taskNumber === -1 && status !== QuickStartStatus.NOT_STARTED ? (React.createElement(Button, { variant: "secondary", onClick: onRestart, "data-testid": "qs-drawer-restart" }, SecondaryButtonText.RESTART)) : (taskNumber > -1 && (React.createElement(Button, { variant: "secondary", onClick: onBack, "data-testid": "qs-drawer-back" }, SecondaryButtonText.BACK))), [onRestart, onBack, SecondaryButtonText, status, taskNumber]);
-    const getSideNoteAction = React.useMemo(() => taskNumber !== -1 && (React.createElement(Button, { variant: "link", onClick: onRestart, "data-testid": "qs-drawer-side-note-action" }, SecondaryButtonText.RESTART)), [taskNumber, onRestart, SecondaryButtonText.RESTART]);
-    return (React.createElement("div", { className: css('pfext-quick-start-footer', className) },
-        React.createElement(ActionList, null,
-            React.createElement(ActionListGroup, null,
-                React.createElement(ActionListItem, null, getPrimaryButton),
-                React.createElement(ActionListItem, null, getSecondaryButton)),
-            React.createElement(ActionListGroup, null,
-                React.createElement(ActionListItem, null, getSideNoteAction)))));
+    const getPrimaryButton = useMemo(() => (jsx(Button, Object.assign({ variant: "primary", className: "pfext-quick-start-footer__actionbtn", onClick: onNext, "data-testid": `qs-drawer-${camelize(getPrimaryButtonText)}`, "data-test": `${getPrimaryButtonText} button` }, { children: getPrimaryButtonText }))), [getPrimaryButtonText, onNext]);
+    const getSecondaryButton = useMemo(() => taskNumber === -1 && status !== QuickStartStatus.NOT_STARTED ? (jsx(Button, Object.assign({ variant: "secondary", onClick: onRestart, "data-testid": "qs-drawer-restart" }, { children: SecondaryButtonText.RESTART }))) : (taskNumber > -1 && (jsx(Button, Object.assign({ variant: "secondary", onClick: onBack, "data-testid": "qs-drawer-back" }, { children: SecondaryButtonText.BACK })))), [onRestart, onBack, SecondaryButtonText, status, taskNumber]);
+    const getSideNoteAction = useMemo(() => taskNumber !== -1 && (jsx(Button, Object.assign({ variant: "link", onClick: onRestart, "data-testid": "qs-drawer-side-note-action" }, { children: SecondaryButtonText.RESTART }))), [taskNumber, onRestart, SecondaryButtonText.RESTART]);
+    return (jsx("div", Object.assign({ className: css('pfext-quick-start-footer', className) }, { children: jsxs(ActionList, { children: [jsxs(ActionListGroup, { children: [jsx(ActionListItem, { children: getPrimaryButton }), jsx(ActionListItem, { children: getSecondaryButton })] }), jsx(ActionListGroup, { children: jsx(ActionListItem, { children: getSideNoteAction }) })] }) })));
 };
 
 const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerClass, }) => {
     const { metadata: { name }, spec: { tasks = [] }, } = quickStart;
     const totalTasks = tasks === null || tasks === void 0 ? void 0 : tasks.length;
-    const { activeQuickStartID, allQuickStartStates, setAllQuickStartStates, activeQuickStartState, setActiveQuickStart, setQuickStartTaskNumber, setQuickStartTaskStatus, nextStep, previousStep, } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const { activeQuickStartID, allQuickStartStates, setAllQuickStartStates, activeQuickStartState, setActiveQuickStart, setQuickStartTaskNumber, setQuickStartTaskStatus, nextStep, previousStep, } = useContext(QuickStartContext);
+    useEffect(() => {
         // If activeQuickStartID was changed through prop from QuickStartContainer, need to init the state if it does not exist yet
         if (activeQuickStartID && !allQuickStartStates[activeQuickStartID]) {
             setAllQuickStartStates(Object.assign(Object.assign({}, allQuickStartStates), { [activeQuickStartID]: getDefaultQuickStartState() }));
@@ -2051,9 +2013,9 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
     const status = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.status;
     const taskNumber = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.taskNumber;
     const allTaskStatuses = tasks.map((task, index) => activeQuickStartState[`taskStatus${index}`]);
-    const handleQuickStartChange = React.useCallback((quickStartId) => setActiveQuickStart(quickStartId), [setActiveQuickStart]);
-    const handleTaskStatusChange = React.useCallback((newTaskStatus) => setQuickStartTaskStatus(newTaskStatus), [setQuickStartTaskStatus]);
-    const getQuickStartActiveTask = React.useCallback(() => {
+    const handleQuickStartChange = useCallback((quickStartId) => setActiveQuickStart(quickStartId), [setActiveQuickStart]);
+    const handleTaskStatusChange = useCallback((newTaskStatus) => setQuickStartTaskStatus(newTaskStatus), [setQuickStartTaskStatus]);
+    const getQuickStartActiveTask = useCallback(() => {
         let activeTaskNumber = 0;
         while (activeTaskNumber !== totalTasks &&
             activeQuickStartState[`taskStatus${activeTaskNumber}`] === QuickStartTaskStatus.SUCCESS) {
@@ -2061,11 +2023,11 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
         }
         return activeTaskNumber;
     }, [totalTasks, activeQuickStartState]);
-    const handleQuickStartContinue = React.useCallback(() => {
+    const handleQuickStartContinue = useCallback(() => {
         const activeTaskNumber = getQuickStartActiveTask();
         setQuickStartTaskNumber(name, activeTaskNumber);
     }, [getQuickStartActiveTask, setQuickStartTaskNumber, name]);
-    const handleNext = React.useCallback(() => {
+    const handleNext = useCallback(() => {
         if (status === QuickStartStatus.COMPLETE && taskNumber === totalTasks) {
             return handleQuickStartChange('');
         }
@@ -2074,13 +2036,11 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
         }
         return nextStep(totalTasks);
     }, [handleQuickStartChange, nextStep, status, taskNumber, totalTasks, handleQuickStartContinue]);
-    const handleBack = React.useCallback(() => previousStep(), [previousStep]);
-    const handleTaskSelect = React.useCallback((selectedTaskNumber) => {
+    const handleBack = useCallback(() => previousStep(), [previousStep]);
+    const handleTaskSelect = useCallback((selectedTaskNumber) => {
         setQuickStartTaskNumber(name, selectedTaskNumber);
     }, [name, setQuickStartTaskNumber]);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(QuickStartContent, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskSelect: handleTaskSelect, onTaskReview: handleTaskStatusChange, onQuickStartChange: handleQuickStartChange, ref: contentRef }),
-        React.createElement(QuickStartFooter, { status: status, taskNumber: taskNumber, totalTasks: totalTasks, onNext: handleNext, onBack: handleBack, className: footerClass, quickStartId: quickStart.metadata.name })));
+    return (jsxs(Fragment$1, { children: [jsx(QuickStartContent, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskSelect: handleTaskSelect, onTaskReview: handleTaskStatusChange, onQuickStartChange: handleQuickStartChange, ref: contentRef }), jsx(QuickStartFooter, { status: status, taskNumber: taskNumber, totalTasks: totalTasks, onNext: handleNext, onBack: handleBack, className: footerClass, quickStartId: quickStart.metadata.name })] }));
 };
 
 const getElement = (appendTo) => {
@@ -2090,7 +2050,7 @@ const getElement = (appendTo) => {
     return appendTo;
 };
 const useScrollTopOnTaskNumberChange = (node, taskNumber) => {
-    React.useEffect(() => {
+    useEffect(() => {
         if (node) {
             node.scrollTo({ top: 0, behavior: 'smooth' });
         }
@@ -2098,9 +2058,9 @@ const useScrollTopOnTaskNumberChange = (node, taskNumber) => {
 };
 const QuickStartPanelContent = (_a) => {
     var { quickStarts = [], handleClose, activeQuickStartID, appendTo, isResizable = true, showClose = true, footerClass } = _a, props = __rest(_a, ["quickStarts", "handleClose", "activeQuickStartID", "appendTo", "isResizable", "showClose", "footerClass"]);
-    const titleRef = React.useRef(null);
-    const { getResource, activeQuickStartState, focusOnQuickStart } = React.useContext(QuickStartContext);
-    const [contentRef, setContentRef] = React.useState();
+    const titleRef = useRef(null);
+    const { getResource, activeQuickStartState, focusOnQuickStart } = useContext(QuickStartContext);
+    const [contentRef, setContentRef] = useState();
     const quickStart = quickStarts.find((qs) => qs.metadata.name === activeQuickStartID);
     const taskNumber = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.taskNumber;
     useScrollTopOnTaskNumberChange(contentRef, taskNumber);
@@ -2116,27 +2076,16 @@ const QuickStartPanelContent = (_a) => {
         }
         return Number.parseInt(taskNumber) + 1;
     };
-    React.useEffect(() => {
+    useEffect(() => {
         if (focusOnQuickStart && quickStart) {
             titleRef.current.focus();
         }
     }, [focusOnQuickStart, quickStart]);
-    const content = quickStart ? (React.createElement(DrawerPanelContent, Object.assign({ isResizable: isResizable, "data-testid": `qs-drawer-${camelize(quickStart.spec.displayName)}`, "data-qs": `qs-step-${getStep()}`, "data-test": "quickstart drawer", style: { '--pf-v6-c-drawer__panel--PaddingBlockStart': '0' } }, props),
-        React.createElement("div", { className: "pfext-quick-start-panel-content" },
-            React.createElement(DrawerHead, null,
-                React.createElement("div", { tabIndex: -1, ref: titleRef },
-                    React.createElement(Title, { headingLevel: "h2", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } },
-                        React.createElement("span", null, quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.displayName),
-                        ' '),
-                    React.createElement("span", null, (quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
-                        ? getResource('{{type}} • {{duration, number}} minutes', quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
-                            .replace('{{duration, number}}', quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
-                            .replace('{{type}}', getResource('Type'))
-                        : getResource('Type'))),
-                showClose && (React.createElement(DrawerActions, null,
-                    React.createElement(DrawerCloseButton, { onClick: handleClose, className: "pfext-quick-start-panel-content__close-button", "data-testid": "qs-drawer-close" }))))),
-        React.createElement(DrawerPanelBody, { className: "pfext-quick-start-panel-content__body", "data-test": "content" },
-            React.createElement(QuickStartController, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, footerClass: footerClass, contentRef: setContentRef })))) : null;
+    const content = quickStart ? (jsxs(DrawerPanelContent, Object.assign({ isResizable: isResizable, "data-testid": `qs-drawer-${camelize(quickStart.spec.displayName)}`, "data-qs": `qs-step-${getStep()}`, "data-test": "quickstart drawer", style: { '--pf-v6-c-drawer__panel--PaddingBlockStart': '0' } }, props, { children: [jsx("div", Object.assign({ className: "pfext-quick-start-panel-content" }, { children: jsxs(DrawerHead, { children: [jsxs("div", Object.assign({ tabIndex: -1, ref: titleRef }, { children: [jsxs(Title, Object.assign({ headingLevel: "h2", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, { children: [jsx("span", { children: quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.displayName }), ' '] })), jsx("span", { children: (quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
+                                        ? getResource('{{type}} • {{duration, number}} minutes', quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
+                                            .replace('{{duration, number}}', quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
+                                            .replace('{{type}}', getResource('Type'))
+                                        : getResource('Type') })] })), showClose && (jsx(DrawerActions, { children: jsx(DrawerCloseButton, { onClick: handleClose, className: "pfext-quick-start-panel-content__close-button", "data-testid": "qs-drawer-close" }) }))] }) })), jsx(DrawerPanelBody, Object.assign({ className: "pfext-quick-start-panel-content__body", "data-test": "content" }, { children: jsx(QuickStartController, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, footerClass: footerClass, contentRef: setContentRef }) }))] }))) : null;
     if (appendTo) {
         return ReactDOM.createPortal(content, getElement(appendTo));
     }
@@ -2145,8 +2094,8 @@ const QuickStartPanelContent = (_a) => {
 
 const QuickStartDrawerContent = (_a) => {
     var { quickStarts = [], appendTo, fullWidth, handleDrawerClose } = _a, props = __rest(_a, ["quickStarts", "appendTo", "fullWidth", "handleDrawerClose"]);
-    const { activeQuickStartID, allQuickStarts = [], activeQuickStartState, } = React.useContext(QuickStartContext);
-    const combinedQuickStarts = allQuickStarts.concat(quickStarts);
+    const { activeQuickStartID, allQuickStarts = [], activeQuickStartState, } = useContext(QuickStartContext);
+    const combinedQuickStarts = [...allQuickStarts, ...quickStarts].filter((qs, idx, arr) => arr.findIndex((q) => q.metadata.name === qs.metadata.name) === idx);
     const handleClose = () => {
         handleDrawerClose && handleDrawerClose(activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.status);
     };
@@ -2157,14 +2106,14 @@ const QuickStartDrawerContent = (_a) => {
             },
         }
         : {};
-    return (React.createElement(QuickStartPanelContent, Object.assign({ quickStarts: combinedQuickStarts, handleClose: handleClose, activeQuickStartID: activeQuickStartID, appendTo: appendTo, isResizable: !fullWidth }, fullWidthPanelStyle, props)));
+    return (jsx(QuickStartPanelContent, Object.assign({ quickStarts: combinedQuickStarts, handleClose: handleClose, activeQuickStartID: activeQuickStartID, appendTo: appendTo, isResizable: !fullWidth }, fullWidthPanelStyle, props)));
 };
 
 const QuickStartDrawer = (_a) => {
     var { quickStarts = [], children, appendTo, fullWidth, onCloseInProgress, onCloseNotInProgress } = _a, props = __rest(_a, ["quickStarts", "children", "appendTo", "fullWidth", "onCloseInProgress", "onCloseNotInProgress"]);
-    const { activeQuickStartID, setActiveQuickStart, allQuickStarts = [], allQuickStartStates, setAllQuickStartStates, } = React.useContext(QuickStartContext);
+    const { activeQuickStartID, setActiveQuickStart, allQuickStarts = [], allQuickStartStates, setAllQuickStartStates, } = useContext(QuickStartContext);
     const combinedQuickStarts = allQuickStarts.concat(quickStarts);
-    React.useEffect(() => {
+    useEffect(() => {
         const params = new URLSearchParams(window.location.search);
         // if there is a quick start param, but the quick start is not active, set it
         // this can happen if a new browser session is opened or an incognito window for example
@@ -2177,13 +2126,13 @@ const QuickStartDrawer = (_a) => {
             }
         }
     }, [activeQuickStartID, combinedQuickStarts, setActiveQuickStart]);
-    React.useEffect(() => {
+    useEffect(() => {
         // If activeQuickStartID was changed through prop from QuickStartContainer, need to init the state if it does not exist yet
         if (activeQuickStartID && !allQuickStartStates[activeQuickStartID]) {
             setAllQuickStartStates(Object.assign(Object.assign({}, allQuickStartStates), { [activeQuickStartID]: getDefaultQuickStartState() }));
         }
     }, [activeQuickStartID, allQuickStartStates, setAllQuickStartStates]);
-    const [modalOpen, setModalOpen] = React.useState(false);
+    const [modalOpen, setModalOpen] = useState(false);
     const onClose = () => setActiveQuickStart('');
     const handleClose = (activeQuickStartStatus) => {
         if (activeQuickStartStatus === QuickStartStatus.IN_PROGRESS) {
@@ -2213,11 +2162,7 @@ const QuickStartDrawer = (_a) => {
             },
         }
         : {};
-    return (React.createElement(React.Fragment, null,
-        React.createElement(Drawer, Object.assign({ isExpanded: !!activeQuickStartID, isInline: true }, props),
-            React.createElement(DrawerContent, Object.assign({ panelContent: React.createElement(QuickStartDrawerContent, { quickStarts: combinedQuickStarts, handleDrawerClose: handleClose, appendTo: appendTo, fullWidth: fullWidth }) }, fullWidthBodyStyle),
-                React.createElement(DrawerContentBody, null, children))),
-        React.createElement(QuickStartCloseModal, { isOpen: modalOpen, onConfirm: onModalConfirm, onCancel: onModalCancel })));
+    return (jsxs(Fragment$1, { children: [jsx(Drawer, Object.assign({ isExpanded: !!activeQuickStartID, isInline: true }, props, { children: jsx(DrawerContent, Object.assign({ panelContent: jsx(QuickStartDrawerContent, { quickStarts: combinedQuickStarts, handleDrawerClose: handleClose, appendTo: appendTo, fullWidth: fullWidth }) }, fullWidthBodyStyle, { children: jsx(DrawerContentBody, { children: children }) })) })), jsx(QuickStartCloseModal, { isOpen: modalOpen, onConfirm: onModalConfirm, onCancel: onModalCancel })] }));
 };
 
 const QuickStartContainer = (_a) => {
@@ -2232,13 +2177,13 @@ const QuickStartContainer = (_a) => {
         useQueryParams,
         markdown,
         alwaysShowTaskReview }, contextProps));
-    React.useEffect(() => {
+    useEffect(() => {
         if (quickStarts &&
             JSON.stringify(quickStarts) !== JSON.stringify(valuesForQuickstartContext.allQuickStarts)) {
             valuesForQuickstartContext.setAllQuickStarts(quickStarts);
         }
     }, [quickStarts, valuesForQuickstartContext]);
-    React.useEffect(() => {
+    useEffect(() => {
         if (loading !== valuesForQuickstartContext.loading) {
             valuesForQuickstartContext.setLoading(loading);
         }
@@ -2247,7 +2192,7 @@ const QuickStartContainer = (_a) => {
         fullWidth,
         onCloseInProgress,
         onCloseNotInProgress }, props);
-    return (React.createElement(QuickStartContext.Provider, { value: valuesForQuickstartContext }, isManagedDrawer ? (React.createElement(QuickStartDrawer, Object.assign({}, drawerProps), children)) : (children)));
+    return (jsx(QuickStartContext.Provider, Object.assign({ value: valuesForQuickstartContext }, { children: isManagedDrawer ? (jsx(QuickStartDrawer, Object.assign({}, drawerProps, { children: children }))) : (children) })));
 };
 
 const HelpTopicContextDefaults = {
@@ -2259,14 +2204,14 @@ const HelpTopicContextDefaults = {
     setFilteredHelpTopics: () => { },
     loading: false,
 };
-const HelpTopicContext = React__default.createContext(HelpTopicContextDefaults);
+const HelpTopicContext = createContext(HelpTopicContextDefaults);
 const useValuesForHelpTopicContext = (value = {}) => {
     const combinedValue = Object.assign(Object.assign({}, HelpTopicContextDefaults), value);
-    const [loading, setLoading] = React__default.useState(combinedValue.loading);
+    const [loading, setLoading] = useState(combinedValue.loading);
     // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    const [helpTopics, setHelpTopics] = React__default.useState(combinedValue.helpTopics || []);
-    const [activeHelpTopic, setActiveHelpTopic] = React__default.useState(combinedValue.activeHelpTopic || null);
-    const setActiveHelpTopicByName = React__default.useCallback((helpTopicName) => {
+    const [helpTopics, setHelpTopics] = useState(combinedValue.helpTopics || []);
+    const [activeHelpTopic, setActiveHelpTopic] = useState(combinedValue.activeHelpTopic || null);
+    const setActiveHelpTopicByName = useCallback((helpTopicName) => {
         const topic = helpTopics.find((t) => t.name === helpTopicName);
         if (!helpTopicName) {
             setActiveHelpTopic(null);
@@ -2274,7 +2219,7 @@ const useValuesForHelpTopicContext = (value = {}) => {
         }
         setActiveHelpTopic(topic);
     }, [helpTopics]);
-    const [filteredHelpTopics, setFilteredHelpTopics] = React__default.useState(combinedValue.filteredHelpTopics || []);
+    const [filteredHelpTopics, setFilteredHelpTopics] = useState(combinedValue.filteredHelpTopics || []);
     return {
         helpTopics,
         setHelpTopics,
@@ -2290,8 +2235,8 @@ const useValuesForHelpTopicContext = (value = {}) => {
 const HelpTopicPanelContent = (_a) => {
     var _b, _c;
     var { activeHelpTopic = null, filteredHelpTopics = [], isResizable = true, onClose } = _a, props = __rest(_a, ["activeHelpTopic", "filteredHelpTopics", "isResizable", "onClose"]);
-    const { setActiveHelpTopicByName } = React.useContext(HelpTopicContext);
-    const [isHelpTopicMenuOpen, setIsHelpTopicMenuOpen] = React.useState(false);
+    const { setActiveHelpTopicByName } = useContext(HelpTopicContext);
+    const [isHelpTopicMenuOpen, setIsHelpTopicMenuOpen] = useState(false);
     const toggleHelpTopicMenu = () => {
         setIsHelpTopicMenuOpen(!isHelpTopicMenuOpen);
     };
@@ -2301,24 +2246,10 @@ const HelpTopicPanelContent = (_a) => {
         toggleHelpTopicMenu();
     };
     const helpTopicOptions = filteredHelpTopics.length > 1 &&
-        filteredHelpTopics.map((topic) => (React.createElement(SelectOption, { key: topic.name, value: topic.name }, topic.title)));
-    const paddingContainer = (children) => React.createElement("div", { style: { padding: '24px' } }, children);
-    const panelBodyItems = (React.createElement(React.Fragment, null,
-        paddingContainer(React.createElement(QuickStartMarkdownView, { content: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.content })),
-        !!((_b = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _b === void 0 ? void 0 : _b.length) && React.createElement(Divider, null),
-        paddingContainer(React.createElement(Stack, { hasGutter: true }, (_c = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _c === void 0 ? void 0 : _c.map(({ href, text, newTab, isExternal }, index) => (React.createElement(StackItem, { key: index },
-            React.createElement(Button, { component: "a", href: href, target: newTab ? '_blank' : '', rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: isExternal ? React.createElement(ExternalLinkAltIcon, null) : null, iconPosition: "right", style: { fontSize: 'inherit' } }, text || href))))))));
-    const content = (React.createElement(DrawerPanelContent, Object.assign({ isResizable: isResizable }, props),
-        React.createElement("div", null,
-            React.createElement(DrawerHead, null,
-                React.createElement("div", null,
-                    helpTopicOptions && (React.createElement(Select, { isPlain: true, id: "help-topics-select", selected: activeHelpTopic, isOpen: isHelpTopicMenuOpen, onSelect: onSelectHelpTopic, onOpenChange: (isOpen) => setIsHelpTopicMenuOpen(isOpen), toggle: (toggleRef) => (React.createElement(MenuToggle, { isFullWidth: true, ref: toggleRef, icon: React.createElement(BarsIcon, null), onClick: toggleHelpTopicMenu, isExpanded: isHelpTopicMenuOpen }, activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title)) },
-                        React.createElement(SelectList, null, helpTopicOptions))),
-                    React.createElement(Title, { headingLevel: "h1", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title)),
-                React.createElement(DrawerActions, null,
-                    React.createElement(DrawerCloseButton, { onClick: onClose, "data-testid": "qs-drawer-close" }))),
-            React.createElement(Divider, null),
-            React.createElement(DrawerPanelBody, { "data-test": "content" }, panelBodyItems))));
+        filteredHelpTopics.map((topic) => (jsx(SelectOption, Object.assign({ value: topic.name }, { children: topic.title }), topic.name)));
+    const paddingContainer = (children) => jsx("div", Object.assign({ style: { padding: '24px' } }, { children: children }));
+    const panelBodyItems = (jsxs(Fragment$1, { children: [paddingContainer(jsx(QuickStartMarkdownView, { content: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.content })), !!((_b = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _b === void 0 ? void 0 : _b.length) && jsx(Divider, {}), paddingContainer(jsx(Stack, Object.assign({ hasGutter: true }, { children: (_c = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _c === void 0 ? void 0 : _c.map(({ href, text, newTab, isExternal }, index) => (jsx(StackItem, { children: jsx(Button, Object.assign({ component: "a", href: href, target: newTab ? '_blank' : '', rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: isExternal ? jsx(ExternalLinkAltIcon, {}) : null, iconPosition: "right", style: { fontSize: 'inherit' } }, { children: text || href })) }, index))) })))] }));
+    const content = (jsx(DrawerPanelContent, Object.assign({ isResizable: isResizable }, props, { children: jsxs("div", { children: [jsxs(DrawerHead, { children: [jsxs("div", { children: [helpTopicOptions && (jsx(Select, Object.assign({ isPlain: true, id: "help-topics-select", selected: activeHelpTopic, isOpen: isHelpTopicMenuOpen, onSelect: onSelectHelpTopic, onOpenChange: (isOpen) => setIsHelpTopicMenuOpen(isOpen), toggle: (toggleRef) => (jsx(MenuToggle, Object.assign({ isFullWidth: true, ref: toggleRef, icon: jsx(BarsIcon, {}), onClick: toggleHelpTopicMenu, isExpanded: isHelpTopicMenuOpen }, { children: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title }))) }, { children: jsx(SelectList, { children: helpTopicOptions }) }))), jsx(Title, Object.assign({ headingLevel: "h1", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, { children: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title }))] }), jsx(DrawerActions, { children: jsx(DrawerCloseButton, { onClick: onClose, "data-testid": "qs-drawer-close" }) })] }), jsx(Divider, {}), jsx(DrawerPanelBody, Object.assign({ "data-test": "content" }, { children: panelBodyItems }))] }) })));
     return content;
 };
 
@@ -2327,30 +2258,27 @@ const HelpTopicContainer = (_a) => {
     const valuesForHelpTopicContext = useValuesForHelpTopicContext(Object.assign({ helpTopics,
         language, resourceBundle: Object.assign({}, resourceBundle), loading,
         markdown }, contextProps));
-    React.useEffect(() => {
+    useEffect(() => {
         if (loading !== valuesForHelpTopicContext.loading) {
             valuesForHelpTopicContext.setLoading(loading);
         }
     }, [loading, valuesForHelpTopicContext]);
-    React.useEffect(() => {
+    useEffect(() => {
         if (helpTopics &&
             JSON.stringify(helpTopics) !== JSON.stringify(valuesForHelpTopicContext.helpTopics)) {
             valuesForHelpTopicContext.setHelpTopics(helpTopics);
         }
     }, [helpTopics, valuesForHelpTopicContext]);
-    return (React.createElement(HelpTopicContext.Provider, { value: valuesForHelpTopicContext },
-        React.createElement(HelpTopicDrawer, Object.assign({}, props), children)));
+    return (jsx(HelpTopicContext.Provider, Object.assign({ value: valuesForHelpTopicContext }, { children: jsx(HelpTopicDrawer, Object.assign({}, props, { children: children })) })));
 };
 const HelpTopicDrawer = (_a) => {
     var { children } = _a, props = __rest(_a, ["children"]);
-    const { activeHelpTopic, filteredHelpTopics, setActiveHelpTopicByName } = React.useContext(HelpTopicContext);
+    const { activeHelpTopic, filteredHelpTopics, setActiveHelpTopicByName } = useContext(HelpTopicContext);
     const onClose = () => {
         setActiveHelpTopicByName('');
     };
-    const panelContent = (React.createElement(HelpTopicPanelContent, { activeHelpTopic: activeHelpTopic, filteredHelpTopics: filteredHelpTopics, onClose: onClose }));
-    return (React.createElement(React.Fragment, null,
-        React.createElement(Drawer, Object.assign({ isExpanded: !!activeHelpTopic, isInline: true }, props), children ? (React.createElement(DrawerContent, { panelContent: panelContent },
-            React.createElement(DrawerContentBody, null, children))) : (React.createElement("div", { className: "pf-v6-c-drawer__main" }, panelContent)))));
+    const panelContent = (jsx(HelpTopicPanelContent, { activeHelpTopic: activeHelpTopic, filteredHelpTopics: filteredHelpTopics, onClose: onClose }));
+    return (jsx(Fragment$1, { children: jsx(Drawer, Object.assign({ isExpanded: !!activeHelpTopic, isInline: true }, props, { children: children ? (jsx(DrawerContent, Object.assign({ panelContent: panelContent }, { children: jsx(DrawerContentBody, { children: children }) }))) : (jsx("div", Object.assign({ className: "pf-v6-c-drawer__main" }, { children: panelContent }))) })) }));
 };
 
 const useLocalStorage = (key, initialValue) => {