@patternfly/quickstarts 6.2.2 → 6.3.0-prerelease.10

package/dist/index.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
 var reactCore = require('@patternfly/react-core');
 var SearchIcon = require('@patternfly/react-icons/dist/js/icons/search-icon');
 var reactStyles = require('@patternfly/react-styles');
@@ -45,8 +46,6 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var SearchIcon__default = /*#__PURE__*/_interopDefaultLegacy(SearchIcon);
 var RocketIcon__default = /*#__PURE__*/_interopDefaultLegacy(RocketIcon);
 var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
@@ -63,18 +62,13 @@ var ArrowRightIcon__default = /*#__PURE__*/_interopDefaultLegacy(ArrowRightIcon)
 var BarsIcon__default = /*#__PURE__*/_interopDefaultLegacy(BarsIcon);
 
 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="";}
@@ -619,7 +613,7 @@ const QuickStartContextDefaults = {
     alwaysShowTaskReview: true,
     focusOnQuickStart: true,
 };
-const QuickStartContext = React.createContext(QuickStartContextDefaults);
+const QuickStartContext = react.createContext(QuickStartContextDefaults);
 const getResource = (resource, options, resourceBundle, lng) => {
     if (options && !isNaN(options.count)) {
         const suffix = pluralResolver.getSuffix(lng, options.count);
@@ -634,27 +628,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["default"].useState(combinedValue.allQuickStarts || []);
-    const [resourceBundle, setResourceBundle] = React__default["default"].useState(Object.assign(Object.assign({}, en), combinedValue.resourceBundle));
-    const [language, setLanguage] = React__default["default"].useState(combinedValue.language);
+    const [quickStarts, setQuickStarts] = react.useState(combinedValue.allQuickStarts || []);
+    const [resourceBundle, setResourceBundle] = react.useState(Object.assign(Object.assign({}, en), combinedValue.resourceBundle));
+    const [language, setLanguage] = react.useState(combinedValue.language);
     const changeResourceBundle = (bundle, lng) => {
         lng && setLanguage(lng);
         setResourceBundle(Object.assign(Object.assign({}, en), bundle));
     };
-    const findResource = React.useCallback((resource, count) => getResource(resource, count !== undefined ? { count } : null, resourceBundle, language), [resourceBundle, language]);
-    const [loading, setLoading] = React__default["default"].useState(combinedValue.loading);
-    const [alwaysShowTaskReview, setAlwaysShowTaskReview] = React__default["default"].useState(combinedValue.alwaysShowTaskReview);
+    const findResource = react.useCallback((resource, count) => getResource(resource, count !== undefined ? { count } : null, resourceBundle, language), [resourceBundle, language]);
+    const [loading, setLoading] = react.useState(combinedValue.loading);
+    const [alwaysShowTaskReview, setAlwaysShowTaskReview] = react.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["default"].useState({
+    const [statusTypes, setStatusTypes] = react.useState({
         [exports.QuickStartStatus.COMPLETE]: findResource('Complete ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[exports.QuickStartStatus.COMPLETE]),
         [exports.QuickStartStatus.IN_PROGRESS]: findResource('In progress ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[exports.QuickStartStatus.IN_PROGRESS]),
         [exports.QuickStartStatus.NOT_STARTED]: findResource('Not started ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[exports.QuickStartStatus.NOT_STARTED]),
     });
-    const [statusFilters, setStatusFilters] = React__default["default"].useState(initialStatusFilters);
-    const [filterKeyword, setFilterKeyword] = React__default["default"].useState(initialSearchQuery);
+    const [statusFilters, setStatusFilters] = react.useState(initialStatusFilters);
+    const [filterKeyword, setFilterKeyword] = react.useState(initialSearchQuery);
     const setFilter = (type, val) => {
         if (type === 'keyword') {
             setFilterKeyword(val);
@@ -663,7 +657,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             setStatusFilters(val);
         }
     };
-    React__default["default"].useEffect(() => {
+    react.useEffect(() => {
         const updatedQuickStartStatusCount = getQuickStartStatusCount(allQuickStartStates, quickStarts);
         setStatusTypes({
             [exports.QuickStartStatus.COMPLETE]: findResource('Complete ({{statusCount, number}})').replace('{{statusCount, number}}', updatedQuickStartStatusCount[exports.QuickStartStatus.COMPLETE]),
@@ -674,7 +668,7 @@ const useValuesForQuickStartContext = (value = {}) => {
     const updateAllQuickStarts = (qs) => {
         setQuickStarts(qs);
     };
-    const setActiveQuickStart = React.useCallback((quickStartId, totalTasks) => {
+    const setActiveQuickStart = react.useCallback((quickStartId, totalTasks) => {
         setActiveQuickStartID((id) => {
             if (!quickStartId || id === quickStartId) {
                 useQueryParams && removeQueryArgument(QUICKSTART_ID_FILTER_KEY);
@@ -687,7 +681,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             ? qs
             : Object.assign(Object.assign({}, qs), { [quickStartId]: getDefaultQuickStartState(totalTasks) }));
     }, [setActiveQuickStartID, setAllQuickStartStates, useQueryParams]);
-    const startQuickStart = React.useCallback((quickStartId, totalTasks) => {
+    const startQuickStart = react.useCallback((quickStartId, totalTasks) => {
         setActiveQuickStartID((id) => {
             if (!id || id !== quickStartId) {
                 useQueryParams && setQueryArgument(QUICKSTART_ID_FILTER_KEY, quickStartId);
@@ -703,7 +697,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             return Object.assign(Object.assign({}, qs), { [quickStartId]: getDefaultQuickStartState(totalTasks, exports.QuickStartStatus.IN_PROGRESS) });
         });
     }, [setActiveQuickStartID, setAllQuickStartStates, useQueryParams]);
-    const restartQuickStart = React.useCallback((quickStartId, totalTasks) => {
+    const restartQuickStart = react.useCallback((quickStartId, totalTasks) => {
         setActiveQuickStartID((id) => {
             if (!id || id !== quickStartId) {
                 useQueryParams && setQueryArgument(QUICKSTART_ID_FILTER_KEY, quickStartId);
@@ -718,7 +712,7 @@ const useValuesForQuickStartContext = (value = {}) => {
     const stepAfterInitial = alwaysShowTaskReview
         ? exports.QuickStartTaskStatus.REVIEW
         : exports.QuickStartTaskStatus.VISITED;
-    const nextStep = React.useCallback((totalTasks) => {
+    const nextStep = react.useCallback((totalTasks) => {
         if (!activeQuickStartID) {
             return;
         }
@@ -757,7 +751,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             return newState;
         });
     }, [activeQuickStartID, setAllQuickStartStates, stepAfterInitial]);
-    const previousStep = React.useCallback(() => {
+    const previousStep = react.useCallback(() => {
         setAllQuickStartStates((qs) => {
             const quickStart = qs[activeQuickStartID];
             const taskNumber = quickStart === null || quickStart === void 0 ? void 0 : quickStart.taskNumber;
@@ -767,7 +761,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             return Object.assign(Object.assign({}, qs), { [activeQuickStartID]: Object.assign(Object.assign({}, quickStart), { taskNumber: taskNumber - 1 }) });
         });
     }, [activeQuickStartID, setAllQuickStartStates]);
-    const setQuickStartTaskNumber = React.useCallback((quickStartId, taskNumber) => {
+    const setQuickStartTaskNumber = react.useCallback((quickStartId, taskNumber) => {
         setAllQuickStartStates((qs) => {
             const quickStart = qs[quickStartId];
             const status = quickStart === null || quickStart === void 0 ? void 0 : quickStart.status;
@@ -787,14 +781,14 @@ const useValuesForQuickStartContext = (value = {}) => {
             return Object.assign(Object.assign({}, qs), { [quickStartId]: updatedQuickStart });
         });
     }, [setAllQuickStartStates, stepAfterInitial]);
-    const setQuickStartTaskStatus = React.useCallback((taskStatus) => {
+    const setQuickStartTaskStatus = react.useCallback((taskStatus) => {
         const quickStart = allQuickStartStates[activeQuickStartID];
         const { taskNumber } = quickStart;
         const updatedQuickStart = Object.assign(Object.assign({}, quickStart), { [getTaskStatusKey(taskNumber)]: taskStatus });
         setAllQuickStartStates((qs) => (Object.assign(Object.assign({}, qs), { [activeQuickStartID]: updatedQuickStart })));
     }, [allQuickStartStates, activeQuickStartID, setAllQuickStartStates]);
     const activeQuickStartState = (_b = allQuickStartStates === null || allQuickStartStates === void 0 ? void 0 : allQuickStartStates[activeQuickStartID]) !== null && _b !== void 0 ? _b : {};
-    const getQuickStartForId = React.useCallback((id) => allQuickStartStates[id], [allQuickStartStates]);
+    const getQuickStartForId = react.useCallback((id) => allQuickStartStates[id], [allQuickStartStates]);
     return {
         allQuickStarts: quickStarts,
         setAllQuickStarts: updateAllQuickStarts,
@@ -835,24 +829,18 @@ const useValuesForQuickStartContext = (value = {}) => {
         setAlwaysShowTaskReview,
     };
 };
-const QuickStartContextProvider = ({ children, value }) => (React__default["default"].createElement(QuickStartContext.Provider, { value: useValuesForQuickStartContext(value) }, children));
+const QuickStartContextProvider = ({ children, value }) => (jsxRuntime.jsx(QuickStartContext.Provider, Object.assign({ value: useValuesForQuickStartContext(value) }, { children: children })));
 
-const Box = ({ children, className }) => (React__namespace.createElement("div", { className: reactStyles.css('pfext-status-box', className) }, children));
-const Loading = ({ className }) => (React__namespace.createElement("div", { className: reactStyles.css('pfext-m-loader', className) },
-    React__namespace.createElement("div", { className: "pfext-m-loader-dot__one" }),
-    React__namespace.createElement("div", { className: "pfext-m-loader-dot__two" }),
-    React__namespace.createElement("div", { className: "pfext-m-loader-dot__three" })));
+const Box = ({ children, className }) => (jsxRuntime.jsx("div", Object.assign({ className: reactStyles.css('pfext-status-box', className) }, { children: children })));
+const Loading = ({ className }) => (jsxRuntime.jsxs("div", Object.assign({ className: reactStyles.css('pfext-m-loader', className) }, { children: [jsxRuntime.jsx("div", { className: "pfext-m-loader-dot__one" }), jsxRuntime.jsx("div", { className: "pfext-m-loader-dot__two" }), jsxRuntime.jsx("div", { className: "pfext-m-loader-dot__three" })] })));
 Loading.displayName = 'Loading';
-const LoadingBox = ({ className, message }) => (React__namespace.createElement(Box, { className: reactStyles.css('pfext-status-box--loading', className) },
-    React__namespace.createElement(Loading, null),
-    message && React__namespace.createElement("div", { className: "pfext-status-box__loading-message" }, message)));
+const LoadingBox = ({ className, message }) => (jsxRuntime.jsxs(Box, Object.assign({ className: reactStyles.css('pfext-status-box--loading', className) }, { children: [jsxRuntime.jsx(Loading, {}), message && jsxRuntime.jsx("div", Object.assign({ className: "pfext-status-box__loading-message" }, { children: message }))] })));
 LoadingBox.displayName = 'LoadingBox';
 const EmptyBox = ({ label }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(Box, null,
-        React__namespace.createElement("div", { "data-test": "empty-message", className: "text-center" }, label
-            ? getResource('No {{label}} found').replace('{{label}}', label)
-            : getResource('Not found'))));
+    const { getResource } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsx(Box, { children: jsxRuntime.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';
 
@@ -866,49 +854,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__namespace.createElement("span", { "data-test": dataTest }, words.map((word, i) => (React__namespace.createElement(React__namespace.Fragment, { key: i },
-        word,
-        i !== words.length - 1 && React__namespace.createElement("wbr", null))))));
+    const rendered = (jsxRuntime.jsx("span", Object.assign({ "data-test": dataTest }, { children: words.map((word, i) => (jsxRuntime.jsxs(react.Fragment, { children: [word, i !== words.length - 1 && jsxRuntime.jsx("wbr", {})] }, i))) })));
     MEMO[value] = rendered;
     return rendered;
 };
 
 const Modal = (_a) => {
     var { isFullScreen = false, className } = _a, props = tslib.__rest(_a, ["isFullScreen", "className"]);
-    return (React__namespace.createElement(deprecated.Modal, Object.assign({}, props, { className: reactStyles.css('pfext-modal', className), appendTo: () => (isFullScreen ? document.body : document.querySelector('#modal-container')) })));
+    return (jsxRuntime.jsx(deprecated.Modal, Object.assign({}, props, { className: reactStyles.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__namespace.useState();
+    const [containerNode, setContainerNode] = react.useState();
     reactCore.useIsomorphicLayoutEffect(() => {
         setContainerNode(getContainer(container) || document.body);
     }, [container]);
-    return containerNode ? ReactDOM__namespace.createPortal(children, containerNode) : null;
+    return containerNode ? ReactDOM.createPortal(children, containerNode) : null;
 };
 
 const SimplePopper = ({ children }) => {
     const openProp = true;
-    const nodeRef = React__namespace.useRef();
-    const popperRef = React__namespace.useRef(null);
-    const [isOpen, setOpenState] = React__namespace.useState(openProp);
-    const setOpen = React__namespace.useCallback((newOpen) => {
+    const nodeRef = react.useRef(null);
+    const popperRef = react.useRef(null);
+    const [isOpen, setOpenState] = react.useState(openProp);
+    const setOpen = react.useCallback((newOpen) => {
         setOpenState(newOpen);
     }, []);
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         setOpen(openProp);
     }, [openProp, setOpen]);
-    const onKeyDown = React__namespace.useCallback((e) => {
+    const onKeyDown = react.useCallback((e) => {
         if (e.keyCode === 27) {
             setOpen(false);
         }
     }, [setOpen]);
-    const onClickOutside = React__namespace.useCallback((e) => {
+    const onClickOutside = react.useCallback((e) => {
         if (!nodeRef.current || (e.target instanceof Node && !nodeRef.current.contains(e.target))) {
             setOpen(false);
         }
     }, [setOpen]);
-    const destroy = React__namespace.useCallback(() => {
+    const destroy = react.useCallback(() => {
         if (popperRef.current) {
             popperRef.current.destroy();
             document.removeEventListener('keydown', onKeyDown, true);
@@ -916,29 +902,28 @@ const SimplePopper = ({ children }) => {
             document.removeEventListener('touchstart', onClickOutside, true);
         }
     }, [onClickOutside, onKeyDown]);
-    const initialize = React__namespace.useCallback(() => {
+    const initialize = react.useCallback(() => {
         if (!nodeRef.current || !isOpen) {
             return;
         }
         destroy();
     }, [isOpen, destroy]);
-    const nodeRefCallback = React__namespace.useCallback((node) => {
+    const nodeRefCallback = react.useCallback((node) => {
         nodeRef.current = node;
         initialize();
     }, [initialize]);
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         initialize();
     }, [initialize]);
-    React__namespace.useEffect(() => () => {
+    react.useEffect(() => () => {
         destroy();
     }, [destroy]);
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (!isOpen) {
             destroy();
         }
     }, [destroy, isOpen]);
-    return isOpen ? (React__namespace.createElement(Portal, null,
-        React__namespace.createElement("div", { ref: nodeRefCallback, style: { zIndex: 9999, position: 'absolute', top: 0, left: 0 }, className: "pfext-quick-start__base" }, children))) : null;
+    return isOpen ? (jsxRuntime.jsx(Portal, { children: jsxRuntime.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) => {
@@ -958,8 +943,8 @@ const InteractiveSpotlight = ({ element }) => {
         bottom,
         right,
     };
-    const [clicked, setClicked] = React__namespace.useState(false);
-    React__namespace.useEffect(() => {
+    const [clicked, setClicked] = react.useState(false);
+    react.useEffect(() => {
         if (!clicked) {
             if (!isInViewport(element)) {
                 element.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
@@ -975,9 +960,7 @@ const InteractiveSpotlight = ({ element }) => {
     if (clicked) {
         return null;
     }
-    return (React__namespace.createElement(Portal, null,
-        React__namespace.createElement(SimplePopper, null,
-            React__namespace.createElement("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-animate", style: style }))));
+    return (jsxRuntime.jsx(Portal, { children: jsxRuntime.jsx(SimplePopper, { children: jsxRuntime.jsx("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-animate", style: style }) }) }));
 };
 
 var ScrollDirection;
@@ -989,8 +972,8 @@ var ScrollDirection;
 })(ScrollDirection || (ScrollDirection = {}));
 
 const useResizeObserver = (callback, targetElement, observerOptions = undefined) => {
-    const element = React__namespace.useMemo(() => targetElement !== null && targetElement !== void 0 ? targetElement : document.querySelector('body'), [targetElement]);
-    React__namespace.useEffect(() => {
+    const element = react.useMemo(() => targetElement !== null && targetElement !== void 0 ? targetElement : document.querySelector('body'), [targetElement]);
+    react.useEffect(() => {
         const observer = new ResizeObserver(callback);
         observer.observe(element, observerOptions);
         return () => {
@@ -1008,8 +991,8 @@ var Shadows;
 })(Shadows || (Shadows = {}));
 
 const useBoundingClientRect = (targetElement) => {
-    const [clientRect, setClientRect] = React__namespace.useState(() => targetElement ? targetElement.getBoundingClientRect() : null);
-    const observerCallback = React__namespace.useCallback(() => {
+    const [clientRect, setClientRect] = react.useState(() => targetElement ? targetElement.getBoundingClientRect() : null);
+    const observerCallback = react.useCallback(() => {
         setClientRect(targetElement ? targetElement.getBoundingClientRect() : null);
     }, [targetElement]);
     useResizeObserver(observerCallback);
@@ -1019,10 +1002,10 @@ const useBoundingClientRect = (targetElement) => {
 /**
  * React hook that forces component render.
  */
-const useForceRender = () => React__namespace.useReducer((s) => !s, false)[1];
+const useForceRender = () => react.useReducer((s) => !s, false)[1];
 
 const useEventListener = (target, event, callback) => {
-    React.useEffect(() => {
+    react.useEffect(() => {
         target.addEventListener(event, callback);
         return () => {
             target.removeEventListener(event, callback);
@@ -1040,14 +1023,12 @@ const StaticSpotlight = ({ element }) => {
             width: clientRect.width,
         }
         : {};
-    return clientRect ? (React__namespace.createElement(Portal, null,
-        React__namespace.createElement("div", { className: "pf-v6-c-backdrop pfext-spotlight__with-backdrop" },
-            React__namespace.createElement("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-noanimate", style: style })))) : null;
+    return clientRect ? (jsxRuntime.jsx(Portal, { children: jsxRuntime.jsx("div", Object.assign({ className: "pf-v6-c-backdrop pfext-spotlight__with-backdrop" }, { children: jsxRuntime.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__namespace.useMemo(() => {
+    const element = react.useMemo(() => {
         const highlightElement = document.querySelector(selector);
         let hiddenElement = highlightElement;
         while (hiddenElement) {
@@ -1062,12 +1043,12 @@ const Spotlight = ({ selector, interactive }) => {
     if (!element) {
         return null;
     }
-    return interactive ? (React__namespace.createElement(InteractiveSpotlight, { element: element })) : (React__namespace.createElement(StaticSpotlight, { element: element }));
+    return interactive ? (jsxRuntime.jsx(InteractiveSpotlight, { element: element })) : (jsxRuntime.jsx(StaticSpotlight, { element: element }));
 };
 
 const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
-    const [selector, setSelector] = React__namespace.useState(null);
-    React__namespace.useEffect(() => {
+    const [selector, setSelector] = react.useState(null);
+    react.useEffect(() => {
         const elements = docContext.querySelectorAll(`${rootSelector} [data-highlight]`);
         let timeoutId;
         function startHighlight(e) {
@@ -1086,7 +1067,7 @@ const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
             elements && elements.forEach((elm) => elm.removeEventListener('click', startHighlight));
         };
     }, [docContext, rootSelector]);
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         const elements = docContext.querySelectorAll(`${rootSelector} [class^=data-highlight__]`);
         let timeoutId;
         function startHighlight(e) {
@@ -1116,7 +1097,7 @@ const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
     if (!selector) {
         return null;
     }
-    return React__namespace.createElement(Spotlight, { selector: selector, interactive: true });
+    return jsxRuntime.jsx(Spotlight, { selector: selector, interactive: true });
 };
 
 const MARKDOWN_COPY_BUTTON_ID = 'data-copy-for';
@@ -1124,15 +1105,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__namespace.useContext(QuickStartContext);
-    const [showSuccessContent, setShowSuccessContent] = React__namespace.useState(false);
-    const textToCopy = React__namespace.useMemo(() => {
+const CopyClipboard = ({ element, rootSelector, docContext }) => {
+    const { getResource } = react.useContext(QuickStartContext);
+    const [showSuccessContent, setShowSuccessContent] = react.useState(false);
+    const textToCopy = react.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__namespace.useCallback(() => {
+    useEventListener(element, 'click', react.useCallback(() => {
         navigator.clipboard
             .writeText(textToCopy.trim())
             .then(() => {
@@ -1140,24 +1121,24 @@ const CopyClipboard = ({ element, rootSelector, docContext, }) => {
         })
             .catch(() => { });
     }, [textToCopy]));
-    useEventListener(element, 'mouseleave', React__namespace.useCallback(() => {
+    useEventListener(element, 'mouseleave', react.useCallback(() => {
         setShowSuccessContent(false);
     }, []));
-    return showSuccessContent ? (React__namespace.createElement(reactCore.Tooltip, { key: "after-copy", isVisible: true, triggerRef: () => element, content: getResource('Successfully copied to clipboard!'), className: "pfext-quick-start__base" })) : (React__namespace.createElement(reactCore.Tooltip, { key: "before-copy", triggerRef: () => element, content: getResource('Copy to clipboard'), className: "pfext-quick-start__base" }));
+    return showSuccessContent ? (jsxRuntime.jsx(reactCore.Tooltip, { isVisible: true, triggerRef: () => element, content: getResource('Successfully copied to clipboard!'), className: "pfext-quick-start__base" }, "after-copy")) : (jsxRuntime.jsx(reactCore.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__namespace.createElement(React__namespace.Fragment, null, Array.from(elements).map((elm) => {
-        const attributeValue = elm.getAttribute(MARKDOWN_COPY_BUTTON_ID);
-        return (React__namespace.createElement(CopyClipboard, { key: attributeValue, element: elm, rootSelector: rootSelector, docContext: docContext }));
-    }))) : null;
+    return elements.length > 0 ? (jsxRuntime.jsx(jsxRuntime.Fragment, { children: Array.from(elements).map((elm) => {
+            const attributeValue = elm.getAttribute(MARKDOWN_COPY_BUTTON_ID);
+            return (jsxRuntime.jsx(CopyClipboard, { element: elm, rootSelector: rootSelector, docContext: docContext }, attributeValue));
+        }) })) : null;
 };
 
 const removeTemplateWhitespace = (template) => template.replace(/>(?:\s|\n)+</g, '><');
 
 const useInlineCopyClipboardShowdownExtension = () => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return React__namespace.useMemo(() => ({
+    const { getResource } = react.useContext(QuickStartContext);
+    return react.useMemo(() => ({
         type: 'lang',
         regex: /`([^`](.*?)[^`])`{{copy}}/g,
         replace: (text, group, _, groupId) => {
@@ -1169,7 +1150,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}">
-                    ${server.renderToStaticMarkup(React__namespace.createElement(CopyIcon__default["default"], null))}
+                    ${server.renderToStaticMarkup(jsxRuntime.jsx(CopyIcon__default["default"], {}))}
                   </button>
                 </span>
               </span>
@@ -1178,10 +1159,9 @@ const useInlineCopyClipboardShowdownExtension = () => {
     }), [getResource]);
 };
 
-/* eslint-disable max-len */
 const useMultilineCopyClipboardShowdownExtension = () => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return React__namespace.useMemo(() => ({
+    const { getResource } = react.useContext(QuickStartContext);
+    return react.useMemo(() => ({
         type: 'lang',
         regex: /```[\n]\s*((((?!```).)*?\n)+)\s*```{{copy}}/g,
         replace: (text, group, _1, _2, groupId) => {
@@ -1193,7 +1173,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}">
-                      ${server.renderToStaticMarkup(React__namespace.createElement(CopyIcon__default["default"], null))}
+                      ${server.renderToStaticMarkup(jsxRuntime.jsx(CopyIcon__default["default"], {}))}
                     </button>
                   </div>
                 </div>
@@ -1206,6 +1186,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: jsxRuntime.jsx(LightbulbIcon__default["default"], {}) },
+    [AdmonitionType.IMPORTANT]: { variant: 'danger' },
+    [AdmonitionType.CAUTION]: { variant: 'warning', customIcon: jsxRuntime.jsx(FireIcon__default["default"], {}) },
+    [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) => {
+        if (!content || !admonitionLabel || !admonitionType) {
+            return text;
+        }
+        if (admonitionLabel !== 'admonition') {
+            return text;
+        }
+        admonitionType = admonitionType.toUpperCase();
+        // Process markdown content directly using marked
+        const processedContent = marked.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 = (jsxRuntime.jsx(reactCore.Alert, Object.assign({ variant: variant }, (customIcon && { customIcon }), { isInline: true, title: admonitionType, className: "pfext-markdown-admonition" }, { children: jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: sanitizedContent } }) })));
+        return removeTemplateWhitespace(server.renderToStaticMarkup(pfAlert));
+    },
+}), []);
+
+const useCodeShowdownExtension = () => react.useMemo(() => ({
+    type: 'output',
+    regex: /<pre><code>(.*?)\n?<\/code><\/pre>/g,
+    replace: (text, content) => {
+        if (!content) {
+            return text;
+        }
+        const pfCodeBlock = jsxRuntime.jsx(reactCore.CodeBlock, { children: content });
+        return removeTemplateWhitespace(server.renderToStaticMarkup(pfCodeBlock));
+    },
+}), []);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const DOMPurify$1 = require('dompurify');
+const useAccordionShowdownExtension = () => react.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.marked.parseInline(accordionContent);
+        const sanitizedContent = DOMPurify$1.sanitize(processedContent);
+        return removeTemplateWhitespace(server.renderToStaticMarkup(jsxRuntime.jsx(reactCore.Accordion, { children: jsxRuntime.jsxs(reactCore.AccordionItem, { children: [jsxRuntime.jsx(reactCore.AccordionToggle, Object.assign({ id: `${ACCORDION_MARKDOWN_BUTTON_ID}-${accordionId}` }, { children: accordionHeading })), jsxRuntime.jsx(reactCore.AccordionContent, Object.assign({ id: `${ACCORDION_MARKDOWN_CONTENT_ID}-${accordionId}`, hidden: true }, { children: jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: sanitizedContent } }) }))] }) })));
+    },
+}), []);
+
+const AccordionShowdownHandler = ({ buttonElement, contentElement, }) => {
+    const [expanded, setExpanded] = react.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 jsxRuntime.jsx(jsxRuntime.Fragment, {});
+};
+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 ? (jsxRuntime.jsx(jsxRuntime.Fragment, { 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 (jsxRuntime.jsx(AccordionShowdownHandler, { buttonElement: elm, contentElement: content }, elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1]));
+        }) })) : null;
+};
+
+const FallbackImg = ({ src, alt, className, fallback }) => {
+    const [isSrcValid, setIsSrcValid] = react.useState(true);
+    if (src && isSrcValid) {
+        return jsxRuntime.jsx("img", { className: className, src: src, alt: alt, onError: () => setIsSrcValid(false) });
+    }
+    return jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+};
+
+const DASH = '-';
+
+const PopoverStatus = ({ hideHeader, children, isVisible = null, statusBody, title, onHide, onShow, }) => (jsxRuntime.jsx(reactCore.Popover, Object.assign({ position: reactCore.PopoverPosition.right, headerContent: hideHeader ? null : title, bodyContent: children, "aria-label": title, onHide: onHide, onShow: onShow, isVisible: isVisible }, { children: jsxRuntime.jsx(reactCore.Button, Object.assign({ variant: "link", isInline: true }, { children: statusBody })) })));
+
+const StatusIconAndText = ({ icon, title, spin, iconOnly, noTooltip, className, }) => {
+    if (!title) {
+        return jsxRuntime.jsx(jsxRuntime.Fragment, { children: DASH });
+    }
+    return (jsxRuntime.jsxs("span", Object.assign({ className: reactStyles.css('pfext-icon-and-text', className), title: iconOnly && !noTooltip ? title : undefined }, { children: [icon &&
+                react.cloneElement(icon, {
+                    className: reactStyles.css(spin && 'fa-spin', icon.props.className, !iconOnly && 'pfext-icon-and-text__icon pfext-icon-flex-child'),
+                }), !iconOnly && jsxRuntime.jsx(CamelCaseWrap, { value: title, dataTest: "status-text" })] })));
+};
+
+const GenericStatus = (props) => {
+    const { Icon, children, popoverTitle, title, noTooltip, iconOnly } = props, restProps = tslib.__rest(props, ["Icon", "children", "popoverTitle", "title", "noTooltip", "iconOnly"]);
+    const renderIcon = iconOnly && !noTooltip ? jsxRuntime.jsx(Icon, { title: title }) : jsxRuntime.jsx(Icon, {});
+    const statusBody = (jsxRuntime.jsx(StatusIconAndText, Object.assign({}, restProps, { noTooltip: noTooltip, title: title, iconOnly: iconOnly, icon: renderIcon })));
+    return react.Children.toArray(children).length ? (jsxRuntime.jsx(PopoverStatus, Object.assign({ title: popoverTitle || title }, restProps, { statusBody: statusBody }, { children: children }))) : (statusBody);
+};
+
+const GreenCheckCircleIcon = ({ className, title, size }) => (jsxRuntime.jsx(reactCore.Icon, Object.assign({ size: size, status: "success" }, { children: jsxRuntime.jsx(CheckCircleIcon__default["default"], { "data-test": "success-icon", className: className, title: title }) })));
+
+const SuccessStatus = (props) => (jsxRuntime.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 jsxRuntime.jsx(StatusIconAndText, Object.assign({}, statusProps, { icon: jsxRuntime.jsx(SyncAltIcon__default["default"], {}) }));
+        case 'Complete':
+            return jsxRuntime.jsx(SuccessStatus, Object.assign({}, statusProps));
+        default:
+            return jsxRuntime.jsx(jsxRuntime.Fragment, { children: status || DASH });
+    }
+};
+const StatusIcon = ({ status }) => jsxRuntime.jsx(Status, { status: status, iconOnly: true });
+
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const DOMPurify = require('dompurify');
 const markdownConvert = (markdown, extensions) => tslib.__awaiter(void 0, void 0, void 0, function* () {
@@ -1217,7 +1346,7 @@ const markdownConvert = (markdown, extensions) => tslib.__awaiter(void 0, void 0
             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',
@@ -1268,13 +1397,82 @@ const markdownConvert = (markdown, extensions) => tslib.__awaiter(void 0, void 0
     const reversedMarkdown = reverseString(markdown);
     const reverseMarkdownWithSubstitutedCodeFences = reversedMarkdown.replace(/{{```((.|\n)*?)```/g, '{{@@@$1@@@');
     const markdownWithSubstitutedCodeFences = reverseString(reverseMarkdownWithSubstitutedCodeFences);
-    const parsedMarkdown = yield marked.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.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.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.marked.parse(markdownAfter);
+            parsedMarkdown += parsed;
+        }
+    }
+    else {
+        // No HTML blocks found, process normally
+        parsedMarkdown = yield marked.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);
             }
@@ -1285,9 +1483,9 @@ const markdownConvert = (markdown, extensions) => tslib.__awaiter(void 0, void 0
     return DOMPurify.sanitize(md);
 });
 const SyncMarkdownView = ({ content, emptyMsg, extensions, renderExtension, exactHeight, inline, className, }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    const [markup, setMarkup] = React__namespace.useState('');
-    React__namespace.useEffect(() => {
+    const { getResource } = react.useContext(QuickStartContext);
+    const [markup, setMarkup] = react.useState('');
+    react.useEffect(() => {
         function getMd() {
             return tslib.__awaiter(this, void 0, void 0, function* () {
                 const md = yield markdownConvert(content || emptyMsg || getResource('Not available'), extensions);
@@ -1303,7 +1501,7 @@ const SyncMarkdownView = ({ content, emptyMsg, extensions, renderExtension, exac
         isEmpty: !content,
         className,
     };
-    return inline ? React__namespace.createElement(InlineMarkdownView, Object.assign({}, innerProps)) : React__namespace.createElement(IFrameMarkdownView, Object.assign({}, innerProps));
+    return inline ? jsxRuntime.jsx(InlineMarkdownView, Object.assign({}, innerProps)) : jsxRuntime.jsx(IFrameMarkdownView, Object.assign({}, innerProps));
 };
 const uniqueId = (function () {
     let num = 0;
@@ -1315,8 +1513,8 @@ const uniqueId = (function () {
 })();
 const RenderExtension = ({ renderExtension, selector, markup, docContext, }) => {
     const forceRender = useForceRender();
-    const markupRef = React__namespace.useRef(null);
-    const shouldRenderExtension = React__namespace.useCallback(() => {
+    const markupRef = react.useRef(null);
+    const shouldRenderExtension = react.useCallback(() => {
         if (markupRef.current === markup) {
             return true;
         }
@@ -1329,25 +1527,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__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (renderExtension) {
             forceRender();
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [markup]);
-    return (React__namespace.createElement(React__namespace.Fragment, null, shouldRenderExtension() ? renderExtension === null || renderExtension === void 0 ? void 0 : renderExtension(docContext !== null && docContext !== void 0 ? docContext : document, selector) : null));
+    return (jsxRuntime.jsx(jsxRuntime.Fragment, { 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__namespace.useMemo(() => uniqueId('markdown'), []);
-    return (React__namespace.createElement("div", { className: reactStyles.css({ 'is-empty': isEmpty }, className), id: id },
-        React__namespace.createElement("div", { dangerouslySetInnerHTML: { __html: markup } }),
-        renderExtension && (React__namespace.createElement(RenderExtension, { renderExtension: renderExtension, selector: `#${id}`, markup: markup }))));
+    const id = react.useMemo(() => uniqueId('markdown'), []);
+    return (jsxRuntime.jsxs("div", Object.assign({ className: reactStyles.css({ 'is-empty': isEmpty }, className), id: id }, { children: [jsxRuntime.jsx("div", { style: { marginBlockEnd: 'var(--pf-t-global--spacer--md)' }, dangerouslySetInnerHTML: { __html: markup } }), renderExtension && (jsxRuntime.jsx(RenderExtension, { renderExtension: renderExtension, selector: `#${id}`, markup: markup }))] })));
 };
 const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, className, }) => {
-    const [frame, setFrame] = React__namespace.useState();
-    const [loaded, setLoaded] = React__namespace.useState(false);
-    const updateTimeoutHandle = React__namespace.useRef();
-    const updateDimensions = React__namespace.useCallback(() => {
+    const [frame, setFrame] = react.useState();
+    const [loaded, setLoaded] = react.useState(false);
+    const updateTimeoutHandle = react.useRef(null);
+    const updateDimensions = react.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;
@@ -1364,10 +1560,10 @@ const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, cla
             }
         });
     }, [frame, exactHeight]);
-    React__namespace.useEffect(() => () => {
+    react.useEffect(() => () => {
         clearTimeout(updateTimeoutHandle.current);
     }, []);
-    const onLoad = React__namespace.useCallback(() => {
+    const onLoad = react.useCallback(() => {
         updateDimensions();
         setLoaded(true);
     }, [updateDimensions]);
@@ -1400,9 +1596,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__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.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__namespace.createElement(RenderExtension, { markup: markup, selector: '', renderExtension: renderExtension, docContext: frame.contentDocument }))));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.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 && (jsxRuntime.jsx(RenderExtension, { markup: markup, selector: '', renderExtension: renderExtension, docContext: frame.contentDocument }))] }));
 };
 
 const LINK_LABEL = '[\\d\\w\\s-()$!]+';
@@ -1412,13 +1608,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__namespace.useContext(QuickStartContext);
+    const { markdown } = react.useContext(QuickStartContext);
     const inlineCopyClipboardShowdownExtension = useInlineCopyClipboardShowdownExtension();
     const multilineCopyClipboardShowdownExtension = useMultilineCopyClipboardShowdownExtension();
     const admonitionShowdownExtension = useAdmonitionShowdownExtension();
     const codeShowdownExtension = useCodeShowdownExtension();
     const accordionShowdownExtension = useAccordionShowdownExtension();
-    return (React__namespace.createElement(SyncMarkdownView, { inline: true, content: content, exactHeight: exactHeight, extensions: [
+    return (jsxRuntime.jsx(SyncMarkdownView, { inline: true, content: content, exactHeight: exactHeight, extensions: [
             {
                 type: 'lang',
                 regex: HIGHLIGHT_REGEXP,
@@ -1443,203 +1639,45 @@ const QuickStartMarkdownView = ({ content, exactHeight, className, }) => {
             codeShowdownExtension,
             accordionShowdownExtension,
             ...(markdown ? markdown.extensions : []),
-        ], renderExtension: (docContext, rootSelector) => (React__namespace.createElement(React__namespace.Fragment, null,
-            React__namespace.createElement(AccordionRenderExtension, { docContext: docContext }),
-            React__namespace.createElement(MarkdownHighlightExtension, { docContext: docContext, rootSelector: rootSelector }),
-            React__namespace.createElement(MarkdownCopyClipboard, { docContext: docContext, rootSelector: rootSelector }),
-            markdown &&
-                markdown.renderExtension &&
-                markdown.renderExtension(docContext, rootSelector))), className: className }));
+        ], renderExtension: (docContext, rootSelector) => (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(AccordionRenderExtension, { docContext: docContext }), jsxRuntime.jsx(MarkdownHighlightExtension, { docContext: docContext, rootSelector: rootSelector }), jsxRuntime.jsx(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__namespace.createElement(LightbulbIcon__default["default"], null) },
-    [AdmonitionType.IMPORTANT]: { variant: 'danger' },
-    [AdmonitionType.CAUTION]: { variant: 'warning', customIcon: React__namespace.createElement(FireIcon__default["default"], null) },
-    [AdmonitionType.WARNING]: { variant: 'warning' },
-};
-const useAdmonitionShowdownExtension = () => 
-// const { getResource } = React.useContext<QuickStartContextValues>(QuickStartContext);
-React__namespace.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__namespace.createElement(QuickStartMarkdownView, { content: content });
-        const pfAlert = (React__namespace.createElement(reactCore.Alert, Object.assign({ variant: variant }, (customIcon && { customIcon }), { isInline: true, title: admonitionType, className: "pfext-markdown-admonition" }), mdContent));
-        return removeTemplateWhitespace(server.renderToStaticMarkup(pfAlert));
-    },
-}), []);
-
-const useCodeShowdownExtension = () => React__namespace.useMemo(() => ({
-    type: 'output',
-    regex: /<pre><code>(.*?)\n?<\/code><\/pre>/g,
-    replace: (text, content) => {
-        if (!content) {
-            return text;
-        }
-        const pfCodeBlock = React__namespace.createElement(reactCore.CodeBlock, null, content);
-        return removeTemplateWhitespace(server.renderToStaticMarkup(pfCodeBlock));
-    },
-}), []);
-
-const useAccordionShowdownExtension = () => React__namespace.useMemo(() => ({
-    type: 'lang',
-    regex: /\[(.+)]{{(accordion) ("(.*?)")}}/g,
-    replace: (_text, accordionContent, _command, accordionHeading) => {
-        const accordionId = String(accordionHeading).replace(/\s/g, '-');
-        return removeTemplateWhitespace(server.renderToStaticMarkup(React__namespace.createElement(React__namespace.Fragment, null,
-            React__namespace.createElement(reactCore.Accordion, { asDefinitionList: true },
-                React__namespace.createElement(reactCore.AccordionItem, { isExpanded: false },
-                    React__namespace.createElement(reactCore.AccordionToggle, { id: `${ACCORDION_MARKDOWN_BUTTON_ID}-${accordionId}` }, accordionHeading),
-                    React__namespace.createElement(reactCore.AccordionContent, { id: `${ACCORDION_MARKDOWN_CONTENT_ID}-${accordionId}` }, accordionContent))))));
-    },
-}), []);
-
-const AccordionShowdownHandler = ({ buttonElement, contentElement, }) => {
-    const [expanded, setExpanded] = React__namespace.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__namespace.createElement(React__namespace.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__namespace.createElement(React__namespace.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__namespace.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__namespace.useState(true);
-    if (src && isSrcValid) {
-        return React__namespace.createElement("img", { className: className, src: src, alt: alt, onError: () => setIsSrcValid(false) });
-    }
-    return React__namespace.createElement(React__namespace.Fragment, null, fallback);
-};
-
-const DASH = '-';
-
-const PopoverStatus = ({ hideHeader, children, isVisible = null, statusBody, title, onHide, onShow, }) => (React__namespace.createElement(reactCore.Popover, { position: reactCore.PopoverPosition.right, headerContent: hideHeader ? null : title, bodyContent: children, "aria-label": title, onHide: onHide, onShow: onShow, isVisible: isVisible },
-    React__namespace.createElement(reactCore.Button, { variant: "link", isInline: true }, statusBody)));
-
-const StatusIconAndText = ({ icon, title, spin, iconOnly, noTooltip, className, }) => {
-    if (!title) {
-        return React__namespace.createElement(React__namespace.Fragment, null, DASH);
-    }
-    return (React__namespace.createElement("span", { className: reactStyles.css('pfext-icon-and-text', className), title: iconOnly && !noTooltip ? title : undefined },
-        icon &&
-            React__namespace.cloneElement(icon, {
-                className: reactStyles.css(spin && 'fa-spin', icon.props.className, !iconOnly && 'pfext-icon-and-text__icon pfext-icon-flex-child'),
-            }),
-        !iconOnly && React__namespace.createElement(CamelCaseWrap, { value: title, dataTest: "status-text" })));
-};
-
-const GenericStatus = (props) => {
-    const { Icon, children, popoverTitle, title, noTooltip, iconOnly } = props, restProps = tslib.__rest(props, ["Icon", "children", "popoverTitle", "title", "noTooltip", "iconOnly"]);
-    const renderIcon = iconOnly && !noTooltip ? React__namespace.createElement(Icon, { title: title }) : React__namespace.createElement(Icon, null);
-    const statusBody = (React__namespace.createElement(StatusIconAndText, Object.assign({}, restProps, { noTooltip: noTooltip, title: title, iconOnly: iconOnly, icon: renderIcon })));
-    return React__namespace.Children.toArray(children).length ? (React__namespace.createElement(PopoverStatus, Object.assign({ title: popoverTitle || title }, restProps, { statusBody: statusBody }), children)) : (statusBody);
-};
-
-const GreenCheckCircleIcon = ({ className, title, size }) => (React__namespace.createElement(reactCore.Icon, { size: size, status: "success" },
-    React__namespace.createElement(CheckCircleIcon__default["default"], { "data-test": "success-icon", className: className, title: title })));
-
-const SuccessStatus = (props) => (React__namespace.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__namespace.createElement(StatusIconAndText, Object.assign({}, statusProps, { icon: React__namespace.createElement(SyncAltIcon__default["default"], null) }));
-        case 'Complete':
-            return React__namespace.createElement(SuccessStatus, Object.assign({}, statusProps));
-        default:
-            return React__namespace.createElement(React__namespace.Fragment, null, status || DASH);
-    }
-};
-const StatusIcon = ({ status }) => (React__namespace.createElement(Status, { status: status, iconOnly: true }));
-
 const QuickStartTileDescription = ({ description, prerequisites, }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
+    const { getResource } = react.useContext(QuickStartContext);
     const prereqs = prerequisites === null || prerequisites === void 0 ? void 0 : prerequisites.filter((p) => p);
-    const buttonRef = React__namespace.useRef(null);
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement(QuickStartMarkdownView, { content: description }),
-        (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (React__namespace.createElement(reactCore.Flex, { spaceItems: { default: 'spaceItemsSm' } },
-            React__namespace.createElement("h5", null,
-                getResource('Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length),
-                ' '),
-            React__namespace.createElement(reactCore.Button, { variant: "link", isInline: true, "data-testid": "qs-card-prereqs", ref: buttonRef, onClick: (e) => {
-                    e.preventDefault();
-                    e.stopPropagation();
-                }, "aria-label": getResource('Show prerequisites') },
-                React__namespace.createElement(InfoCircleIcon__default["default"], null)),
-            React__namespace.createElement(reactCore.Popover, { "aria-label": getResource('Prerequisites'), headerContent: getResource('Prerequisites'), triggerRef: buttonRef, bodyContent: React__namespace.createElement("div", null,
-                    React__namespace.createElement("ul", { "aria-label": getResource('Prerequisites') }, prereqs.map((prerequisite, index) => (
-                    // eslint-disable-next-line react/no-array-index-key
-                    React__namespace.createElement("li", { key: index },
-                        React__namespace.createElement(QuickStartMarkdownView, { content: prerequisite })))))) })))));
+    const buttonRef = react.useRef(null);
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: description }), (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (jsxRuntime.jsxs(reactCore.Flex, Object.assign({ spaceItems: { default: 'spaceItemsSm' } }, { children: [jsxRuntime.jsxs("h5", { children: [getResource('Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), ' '] }), jsxRuntime.jsx(reactCore.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: jsxRuntime.jsx(InfoCircleIcon__default["default"], {}) })), jsxRuntime.jsx(reactCore.Popover, { "aria-label": getResource('Prerequisites'), headerContent: getResource('Prerequisites'), triggerRef: buttonRef, bodyContent: jsxRuntime.jsx("div", { children: jsxRuntime.jsx("ul", Object.assign({ "aria-label": getResource('Prerequisites') }, { children: prereqs.map((prerequisite, index) => (
+                                // eslint-disable-next-line react/no-array-index-key
+                                jsxRuntime.jsx("li", { children: jsxRuntime.jsx(QuickStartMarkdownView, { content: prerequisite }) }, index))) })) }) })] })))] }));
 };
 
 const QuickStartTileFooter = ({ quickStartId, status, totalTasks, onClickContinue, }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    const { activeQuickStartID, startQuickStart, restartQuickStart } = React__namespace.useContext(QuickStartContext);
-    const start = React__namespace.useCallback(() => {
+    const { getResource } = react.useContext(QuickStartContext);
+    const { activeQuickStartID, startQuickStart, restartQuickStart } = react.useContext(QuickStartContext);
+    const start = react.useCallback(() => {
         startQuickStart(quickStartId, totalTasks);
     }, [quickStartId, startQuickStart, totalTasks]);
-    const restart = React__namespace.useCallback(() => {
+    const restart = react.useCallback(() => {
         restartQuickStart(quickStartId, totalTasks);
     }, [quickStartId, restartQuickStart, totalTasks]);
-    return (React__namespace.createElement(reactCore.Flex, { justifyContent: { default: 'justifyContentSpaceBetween' } },
-        status === exports.QuickStartStatus.NOT_STARTED && (React__namespace.createElement(reactCore.FlexItem, null,
-            React__namespace.createElement(reactCore.Button, { onClick: start, variant: "link", isInline: true, "data-testid": "qs-card-notStarted-start", id: `${quickStartId}-start`, "aria-labelledby": `${quickStartId}-start ${quickStartId}` }, getResource('Start')))),
-        status === exports.QuickStartStatus.IN_PROGRESS && activeQuickStartID !== quickStartId && (React__namespace.createElement(reactCore.FlexItem, null,
-            React__namespace.createElement(reactCore.Button, { variant: "link", onClick: onClickContinue, isInline: true, "data-testid": "qs-card-inProgress-resume", id: `${quickStartId}-continue`, "aria-labelledby": `${quickStartId}-continue ${quickStartId}` }, getResource('Continue')))),
-        status === exports.QuickStartStatus.COMPLETE && (React__namespace.createElement(reactCore.FlexItem, null,
-            React__namespace.createElement(reactCore.Button, { onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-complete-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, getResource('Restart')))),
-        status === exports.QuickStartStatus.IN_PROGRESS && (React__namespace.createElement(reactCore.FlexItem, null,
-            React__namespace.createElement(reactCore.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 (jsxRuntime.jsxs(reactCore.Flex, Object.assign({ justifyContent: { default: 'justifyContentSpaceBetween' } }, { children: [status === exports.QuickStartStatus.NOT_STARTED && (jsxRuntime.jsx(reactCore.FlexItem, { children: jsxRuntime.jsx(reactCore.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 === exports.QuickStartStatus.IN_PROGRESS && activeQuickStartID !== quickStartId && (jsxRuntime.jsx(reactCore.FlexItem, { children: jsxRuntime.jsx(reactCore.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 === exports.QuickStartStatus.COMPLETE && (jsxRuntime.jsx(reactCore.FlexItem, { children: jsxRuntime.jsx(reactCore.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 === exports.QuickStartStatus.IN_PROGRESS && (jsxRuntime.jsx(reactCore.FlexItem, { children: jsxRuntime.jsx(reactCore.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__namespace.createElement(reactCore.Flex, { justifyContent: { default: 'justifyContentSpaceBetween' } },
-        React__namespace.createElement(reactCore.FlexItem, null,
-            React__namespace.createElement(reactCore.Button, { component: "a", href: href, target: "_blank", rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: React__namespace.createElement(ExternalLinkAltIcon__default["default"], null), iconPosition: "right", id: quickStartId, "aria-labelledby": `${quickStartId}-external ${quickStartId}` }, text || href))));
+    return (jsxRuntime.jsx(reactCore.Flex, Object.assign({ justifyContent: { default: 'justifyContentSpaceBetween' } }, { children: jsxRuntime.jsx(reactCore.FlexItem, { children: jsxRuntime.jsx(reactCore.Button, Object.assign({ component: "a", href: href, target: "_blank", rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: jsxRuntime.jsx(ExternalLinkAltIcon__default["default"], {}), iconPosition: "right", id: quickStartId, "aria-labelledby": `${quickStartId}-external ${quickStartId}` }, { children: text || href })) }) })));
 };
 
-const QuickStartTileHeader = ({ name, quickStartId, onSelect, }) => (React__namespace.createElement(reactCore.Flex, { flexWrap: { default: 'nowrap' } },
-    React__namespace.createElement(reactCore.Button, { "data-test": "title", id: quickStartId, variant: "link", isInline: true, onClick: onSelect }, name)));
+const QuickStartTileHeader = ({ name, quickStartId, onSelect }) => (jsxRuntime.jsx(reactCore.Flex, Object.assign({ flexWrap: { default: 'nowrap' } }, { children: jsxRuntime.jsx(reactCore.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__namespace.useContext(QuickStartContext);
+    const { setActiveQuickStart, footer, getResource } = react.useContext(QuickStartContext);
     const statusColorMap = {
         [exports.QuickStartStatus.COMPLETE]: 'green',
         [exports.QuickStartStatus.IN_PROGRESS]: 'purple',
@@ -1652,11 +1690,10 @@ const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, act
     };
     let quickStartIcon;
     if (typeof icon === 'object') {
-        quickStartIcon = React__namespace.createElement(reactCore.Icon, { size: "2xl" }, icon);
+        quickStartIcon = jsxRuntime.jsx(reactCore.Icon, Object.assign({ size: "2xl" }, { children: icon }));
     }
     else {
-        quickStartIcon = (React__namespace.createElement(reactCore.Icon, { size: "2xl" },
-            React__namespace.createElement(FallbackImg, { src: icon, alt: "", className: "pfext-catalog-item-icon__img", fallback: React__namespace.createElement(RocketIcon__default["default"], null) })));
+        quickStartIcon = (jsxRuntime.jsx(reactCore.Icon, Object.assign({ size: "2xl" }, { children: jsxRuntime.jsx(FallbackImg, { src: icon, alt: "", className: "pfext-catalog-item-icon__img", fallback: jsxRuntime.jsx(RocketIcon__default["default"], {}) }) })));
     }
     const onSelect = () => {
         if (!link) {
@@ -1667,70 +1704,53 @@ const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, act
         }
         onClick();
     };
-    const footerComponent = React__namespace.useMemo(() => {
+    const footerComponent = react.useMemo(() => {
         if (footer && footer.show === false) {
             return null;
         }
         if (link) {
-            return React__namespace.createElement(QuickStartTileFooterExternal, { link: link, quickStartId: id });
+            return jsxRuntime.jsx(QuickStartTileFooterExternal, { link: link, quickStartId: id });
         }
-        return (React__namespace.createElement(QuickStartTileFooter, { quickStartId: id, status: status, totalTasks: tasks === null || tasks === void 0 ? void 0 : tasks.length, onClickContinue: onSelect }));
+        return (jsxRuntime.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__default["default"];
-    const additionalAction = action ? (React__namespace.createElement(reactCore.Button, Object.assign({ "aria-label": action['aria-label'], icon: React__namespace.createElement(ActionIcon, null), variant: "plain", onClick: action.onClick }, action.buttonProps))) : undefined;
-    return (React__namespace.createElement(reactCore.Card, Object.assign({ id: `${id}-catalog-tile`, style: { height: '100%' }, "data-testid": `qs-card-${camelize(displayName)}`, className: "pfext-catalog-item" }, (isActive && {
+    const additionalAction = action ? (jsxRuntime.jsx(reactCore.Button, Object.assign({ "aria-label": action['aria-label'], icon: jsxRuntime.jsx(ActionIcon, {}), variant: "plain", onClick: action.onClick }, action.buttonProps))) : undefined;
+    return (jsxRuntime.jsxs(reactCore.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__namespace.createElement(reactCore.CardHeader, Object.assign({}, (action && {
-            actions: { actions: additionalAction },
-        })), quickStartIcon),
-        React__namespace.createElement(reactCore.CardTitle, null,
-            React__namespace.createElement(QuickStartTileHeader, { name: displayName, onSelect: onSelect, quickStartId: id })),
-        React__namespace.createElement(reactCore.CardBody, null,
-            React__namespace.createElement(reactCore.Stack, { hasGutter: true },
-                React__namespace.createElement(reactCore.Flex, { spaceItems: { default: 'spaceItemsSm' } },
-                    type && React__namespace.createElement(reactCore.Label, { color: type.color }, type.text),
-                    durationMinutes && (React__namespace.createElement(reactCore.Label, { variant: "outline", "data-test": "duration", icon: React__namespace.createElement(OutlinedClockIcon__default["default"], null) }, getResource('{{duration, number}} minutes', durationMinutes).replace('{{duration, number}}', durationMinutes))),
-                    status !== exports.QuickStartStatus.NOT_STARTED && (React__namespace.createElement(reactCore.Label, { variant: "outline", color: statusColorMap[status], icon: React__namespace.createElement(StatusIcon, { status: status }), "data-test": "status" }, statusLocaleMap[status]))),
-                React__namespace.createElement(QuickStartTileDescription, { description: description, prerequisites: prerequisites }))),
-        React__namespace.createElement(reactCore.CardFooter, null, footerComponent)));
+    }), { children: [jsxRuntime.jsx(reactCore.CardHeader, Object.assign({}, (action && {
+                actions: { actions: additionalAction },
+            }), { children: quickStartIcon })), jsxRuntime.jsx(reactCore.CardTitle, { children: jsxRuntime.jsx(QuickStartTileHeader, { name: displayName, onSelect: onSelect, quickStartId: id }) }), jsxRuntime.jsx(reactCore.CardBody, { children: jsxRuntime.jsxs(reactCore.Stack, Object.assign({ hasGutter: true }, { children: [jsxRuntime.jsxs(reactCore.Flex, Object.assign({ spaceItems: { default: 'spaceItemsSm' } }, { children: [type && jsxRuntime.jsx(reactCore.Label, Object.assign({ color: type.color }, { children: type.text })), durationMinutes && (jsxRuntime.jsx(reactCore.Label, Object.assign({ variant: "outline", "data-test": "duration", icon: jsxRuntime.jsx(OutlinedClockIcon__default["default"], {}) }, { children: getResource('{{duration, number}} minutes', durationMinutes).replace('{{duration, number}}', durationMinutes) }))), status !== exports.QuickStartStatus.NOT_STARTED && (jsxRuntime.jsx(reactCore.Label, Object.assign({ variant: "outline", color: statusColorMap[status], icon: jsxRuntime.jsx(StatusIcon, { status: status }), "data-test": "status" }, { children: statusLocaleMap[status] })))] })), jsxRuntime.jsx(QuickStartTileDescription, { description: description, prerequisites: prerequisites })] })) }), jsxRuntime.jsx(reactCore.CardFooter, { children: footerComponent })] })));
 };
 
 const QuickStartCatalog = ({ quickStarts }) => {
-    const { activeQuickStartID, allQuickStartStates } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement("div", null,
-        React__namespace.createElement(reactCore.Gallery, { hasGutter: true, className: "pfext-quick-start-catalog__gallery" }, quickStarts.map((quickStart, index) => {
-            const { metadata: { name: id }, } = quickStart;
-            return (React__namespace.createElement(QuickStartTile, { key: index, quickStart: quickStart, isActive: id === activeQuickStartID, status: getQuickStartStatus(allQuickStartStates, id) }));
-        }))));
+    const { activeQuickStartID, allQuickStartStates } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsx("div", { children: jsxRuntime.jsx(reactCore.Gallery, Object.assign({ hasGutter: true, className: "pfext-quick-start-catalog__gallery" }, { children: quickStarts.map((quickStart, index) => {
+                const { metadata: { name: id }, } = quickStart;
+                return (jsxRuntime.jsx(QuickStartTile, { quickStart: quickStart, isActive: id === activeQuickStartID, status: getQuickStartStatus(allQuickStartStates, id) }, index));
+            }) })) }));
 };
 
 const QuickStartCatalogFilterSearch = (_a) => {
     var { searchInputText, handleTextChange } = _a, props = tslib.__rest(_a, ["searchInputText", "handleTextChange"]);
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(reactCore.ToolbarItem, null,
-        React__namespace.createElement(reactCore.SearchInput, Object.assign({ placeholder: getResource('Filter by keyword...'), value: searchInputText, onChange: (_ev, value) => handleTextChange(value), onClear: () => handleTextChange('') }, props))));
+    const { getResource } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsx(reactCore.ToolbarItem, { children: jsxRuntime.jsx(reactCore.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 = tslib.__rest(_a, ["isDropdownOpen", "setIsDropdownOpen", "onRowfilterSelect", "selectedFilters", "dropdownItems"]);
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    const toggle = (toggleRef) => (React__namespace.createElement(reactCore.MenuToggle, { isFullWidth: true, ref: toggleRef, onClick: () => setIsDropdownOpen(!isDropdownOpen), isExpanded: isDropdownOpen },
-        getResource('Status'),
-        selectedFilters.length > 0 && React__namespace.createElement(reactCore.Badge, { isRead: true }, selectedFilters.length)));
-    return (React__namespace.createElement(reactCore.ToolbarItem, null,
-        React__namespace.createElement(reactCore.Select, Object.assign({ "aria-label": getResource('Select filter'), isOpen: isDropdownOpen, selected: selectedFilters, onSelect: onRowfilterSelect, onOpenChange: (isOpen) => setIsDropdownOpen(isOpen), toggle: toggle }, props),
-            React__namespace.createElement(reactCore.SelectList, null, dropdownItems))));
+    const { getResource } = react.useContext(QuickStartContext);
+    const toggle = (toggleRef) => (jsxRuntime.jsxs(reactCore.MenuToggle, Object.assign({ isFullWidth: true, ref: toggleRef, onClick: () => setIsDropdownOpen(!isDropdownOpen), isExpanded: isDropdownOpen }, { children: [getResource('Status'), selectedFilters.length > 0 && jsxRuntime.jsx(reactCore.Badge, Object.assign({ isRead: true }, { children: selectedFilters.length }))] })));
+    return (jsxRuntime.jsx(reactCore.ToolbarItem, { children: jsxRuntime.jsx(reactCore.Select, Object.assign({ "aria-label": getResource('Select filter'), isOpen: isDropdownOpen, selected: selectedFilters, onSelect: onRowfilterSelect, onOpenChange: (isOpen) => setIsDropdownOpen(isOpen), toggle: toggle }, props, { children: jsxRuntime.jsx(reactCore.SelectList, { children: dropdownItems }) })) }));
 };
 const QuickStartCatalogFilterCount = ({ quickStartsCount }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(reactCore.ToolbarItem, { align: { default: 'alignEnd' } }, getResource('{{count, number}} item', quickStartsCount).replace('{{count, number}}', quickStartsCount)));
+    const { getResource } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsx(reactCore.ToolbarItem, Object.assign({ align: { default: 'alignEnd' } }, { children: getResource("{{count, number}} item", quickStartsCount).replace('{{count, number}}', quickStartsCount) })));
 };
 const QuickStartCatalogFilterSearchWrapper = ({ onSearchInputChange = () => { } }) => {
-    const { useQueryParams, filter, setFilter } = React__namespace.useContext(QuickStartContext);
-    React__namespace.useEffect(() => {
+    const { useQueryParams, filter, setFilter } = react.useContext(QuickStartContext);
+    react.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);
@@ -1756,7 +1776,7 @@ const QuickStartCatalogFilterSearchWrapper = ({ onSearchInputChange = () => { }
         }
         onSearchInputChange(val);
     };
-    return (React__namespace.createElement(QuickStartCatalogFilterSearch, { searchInputText: filter === null || filter === void 0 ? void 0 : filter.keyword, handleTextChange: handleTextChange }));
+    return (jsxRuntime.jsx(QuickStartCatalogFilterSearch, { searchInputText: filter === null || filter === void 0 ? void 0 : filter.keyword, handleTextChange: handleTextChange }));
 };
 // compare string/number arrays
 const equalsIgnoreOrder = (a, b) => {
@@ -1774,8 +1794,8 @@ const equalsIgnoreOrder = (a, b) => {
     return true;
 };
 const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) => {
-    const { useQueryParams, filter, setFilter } = React__namespace.useContext(QuickStartContext);
-    React__namespace.useEffect(() => {
+    const { useQueryParams, filter, setFilter } = react.useContext(QuickStartContext);
+    react.useEffect(() => {
         //   use this effect to clear the status when a `clear all` action is performed higher up
         const unlisten = history.listen(({ location }) => {
             var _a;
@@ -1790,8 +1810,8 @@ const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) =>
             unlisten();
         };
     });
-    const [isDropdownOpen, setIsDropdownOpen] = React__namespace.useState(false);
-    const onRowfilterSelect = React__namespace.useCallback((_e, selectedValue) => {
+    const [isDropdownOpen, setIsDropdownOpen] = react.useState(false);
+    const onRowfilterSelect = react.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)
@@ -1808,33 +1828,24 @@ const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) =>
         }
         onStatusChange(selectedFiltersList);
     }, [filter.status.statusFilters, onStatusChange, setFilter, useQueryParams]);
-    const dropdownItems = Object.entries(filter.status.statusTypes).map(([key, value]) => (React__namespace.createElement(reactCore.SelectOption, { key: key, "data-key": key, value: value, hasCheckbox: true, isSelected: filter.status.statusFilters.includes(key) },
-        React__namespace.createElement(React__namespace.Fragment, null, value))));
-    return (React__namespace.createElement(QuickStartCatalogFilterSelect, { isDropdownOpen: isDropdownOpen, setIsDropdownOpen: setIsDropdownOpen, onRowfilterSelect: onRowfilterSelect, selectedFilters: filter.status.statusFilters, dropdownItems: dropdownItems }));
+    const dropdownItems = Object.entries(filter.status.statusTypes).map(([key, value]) => (jsxRuntime.jsx(reactCore.SelectOption, Object.assign({ "data-key": key, value: value, hasCheckbox: true, isSelected: filter.status.statusFilters.includes(key) }, { children: jsxRuntime.jsx(jsxRuntime.Fragment, { children: value }) }), key)));
+    return (jsxRuntime.jsx(QuickStartCatalogFilterSelect, { isDropdownOpen: isDropdownOpen, setIsDropdownOpen: setIsDropdownOpen, onRowfilterSelect: onRowfilterSelect, selectedFilters: filter.status.statusFilters, dropdownItems: dropdownItems }));
 };
-const QuickStartCatalogFilterCountWrapper = ({ quickStartsCount }) => React__namespace.createElement(QuickStartCatalogFilterCount, { quickStartsCount: quickStartsCount });
+const QuickStartCatalogFilterCountWrapper = ({ quickStartsCount, }) => jsxRuntime.jsx(QuickStartCatalogFilterCount, { quickStartsCount: quickStartsCount });
 
 const QuickStartCatalogFilter = (_a) => {
     var { quickStartsCount, onSearchInputChange = () => { }, onStatusChange = () => { } } = _a, props = tslib.__rest(_a, ["quickStartsCount", "onSearchInputChange", "onStatusChange"]);
-    return (React__namespace.createElement(reactCore.Toolbar, Object.assign({}, props),
-        React__namespace.createElement(reactCore.ToolbarContent, null,
-            React__namespace.createElement(QuickStartCatalogFilterSearchWrapper, { onSearchInputChange: onSearchInputChange }),
-            React__namespace.createElement(QuickStartCatalogFilterStatusWrapper, { onStatusChange: onStatusChange }),
-            React__namespace.createElement(QuickStartCatalogFilterCountWrapper, { quickStartsCount: quickStartsCount }))));
+    return (jsxRuntime.jsx(reactCore.Toolbar, Object.assign({}, props, { children: jsxRuntime.jsxs(reactCore.ToolbarContent, { children: [jsxRuntime.jsx(QuickStartCatalogFilterSearchWrapper, { onSearchInputChange: onSearchInputChange }), jsxRuntime.jsx(QuickStartCatalogFilterStatusWrapper, { onStatusChange: onStatusChange }), jsxRuntime.jsx(QuickStartCatalogFilterCountWrapper, { quickStartsCount: quickStartsCount })] }) })));
 };
 
 const QuickStartCatalogEmptyState = ({ clearFilters }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(reactCore.EmptyState, { headingLevel: "h4", icon: SearchIcon__default["default"], titleText: React__namespace.createElement(React__namespace.Fragment, null, getResource('No results found')) },
-        React__namespace.createElement(reactCore.EmptyStateBody, null, getResource('No results match the filter criteria. Remove filters or clear all filters to show results.')),
-        React__namespace.createElement(reactCore.EmptyStateFooter, null,
-            React__namespace.createElement(reactCore.EmptyStateActions, null,
-                React__namespace.createElement(reactCore.Button, { variant: "link", onClick: clearFilters, "data-test": "clear-filter button" }, getResource('Clear all filters'))))));
+    const { getResource } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsxs(reactCore.EmptyState, Object.assign({ headingLevel: "h4", icon: SearchIcon__default["default"], titleText: jsxRuntime.jsx(jsxRuntime.Fragment, { children: getResource('No results found') }) }, { children: [jsxRuntime.jsx(reactCore.EmptyStateBody, { children: getResource('No results match the filter criteria. Remove filters or clear all filters to show results.') }), jsxRuntime.jsx(reactCore.EmptyStateFooter, { children: jsxRuntime.jsx(reactCore.EmptyStateActions, { children: jsxRuntime.jsx(reactCore.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__namespace.useCallback(sortFnc, [sortFnc]);
-    const { allQuickStarts = [], setAllQuickStarts, allQuickStartStates, getResource, filter, setFilter, loading, } = React__namespace.useContext(QuickStartContext);
-    React__namespace.useEffect(() => {
+    const sortFncCallback = react.useCallback(sortFnc, [sortFnc]);
+    const { allQuickStarts = [], setAllQuickStarts, allQuickStartStates, getResource, filter, setFilter, loading, } = react.useContext(QuickStartContext);
+    react.useEffect(() => {
         // passed through prop, not context
         if (quickStarts && JSON.stringify(quickStarts) !== JSON.stringify(allQuickStarts)) {
             setAllQuickStarts(quickStarts);
@@ -1843,8 +1854,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__namespace.useState(initialFilteredQuickStarts);
-    React__namespace.useEffect(() => {
+    const [filteredQuickStarts, setFilteredQuickStarts] = react.useState(initialFilteredQuickStarts);
+    react.useEffect(() => {
         const filteredQs = showFilter
             ? filterQuickStarts(allQuickStarts, filter.keyword, filter.status.statusFilters, allQuickStartStates).sort(sortFncCallback)
             : allQuickStarts;
@@ -1887,59 +1898,37 @@ const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) =>
         }
     };
     if (loading) {
-        return React__namespace.createElement(LoadingBox, null);
+        return jsxRuntime.jsx(LoadingBox, {});
     }
     if (!allQuickStarts || allQuickStarts.length === 0) {
-        return React__namespace.createElement(EmptyBox, { label: getResource('Quick Starts') });
+        return jsxRuntime.jsx(EmptyBox, { label: getResource('Quick Starts') });
     }
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        (showTitle || showFilter) && (React__namespace.createElement(reactCore.PageSection, { hasBodyWrapper: false },
-            showTitle && (React__namespace.createElement(reactCore.Content, { isEditorial: true },
-                React__namespace.createElement(reactCore.Title, { headingLevel: "h1", "data-test": "page-title" }, title || getResource('Quick Starts')),
-                hint && React__namespace.createElement("div", null, hint))),
-            showTitle && React__namespace.createElement(reactCore.Divider, { component: "div" }),
-            showFilter && (React__namespace.createElement(React__namespace.Fragment, null,
-                React__namespace.createElement(QuickStartCatalogFilter, { quickStartsCount: filteredQuickStarts.length, onSearchInputChange: onSearchInputChange, onStatusChange: onStatusChange }))))),
-        React__namespace.createElement(reactCore.PageSection, { hasBodyWrapper: false }, filteredQuickStarts.length === 0 ? (React__namespace.createElement(QuickStartCatalogEmptyState, { clearFilters: clearFilters })) : (React__namespace.createElement(QuickStartCatalog, { quickStarts: filteredQuickStarts })))));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [(showTitle || showFilter) && (jsxRuntime.jsxs(reactCore.PageSection, Object.assign({ hasBodyWrapper: false }, { children: [showTitle && (jsxRuntime.jsxs(reactCore.Content, Object.assign({ isEditorial: true }, { children: [jsxRuntime.jsx(reactCore.Title, Object.assign({ headingLevel: "h1", "data-test": "page-title" }, { children: title || getResource('Quick Starts') })), hint && jsxRuntime.jsx("div", { children: hint })] }))), showTitle && jsxRuntime.jsx(reactCore.Divider, { component: "div" }), showFilter && (jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxRuntime.jsx(QuickStartCatalogFilter, { quickStartsCount: filteredQuickStarts.length, onSearchInputChange: onSearchInputChange, onStatusChange: onStatusChange }) }))] }))), jsxRuntime.jsx(reactCore.PageSection, Object.assign({ hasBodyWrapper: false }, { children: filteredQuickStarts.length === 0 ? (jsxRuntime.jsx(QuickStartCatalogEmptyState, { clearFilters: clearFilters })) : (jsxRuntime.jsx(QuickStartCatalog, { quickStarts: filteredQuickStarts })) }))] }));
 };
 
-const QuickStartCatalogHeader = ({ title, hint, }) => (React__namespace.createElement("div", null,
-    React__namespace.createElement(reactCore.Title, { headingLevel: "h1", "data-pf-content": "true" }, title),
-    hint && React__namespace.createElement("div", null, hint)));
+const QuickStartCatalogHeader = ({ title, hint, }) => (jsxRuntime.jsxs("div", { children: [jsxRuntime.jsx(reactCore.Title, Object.assign({ headingLevel: "h1", "data-pf-content": "true" }, { children: title })), hint && jsxRuntime.jsx("div", { children: hint })] }));
 
-const QuickStartCatalogSection = ({ children }) => (React__namespace.createElement("div", null, children));
+const QuickStartCatalogSection = ({ children }) => (jsxRuntime.jsx("div", { children: children }));
 
-const QuickStartCatalogToolbar = ({ children }) => (React__namespace.createElement(reactCore.Toolbar, null, children));
+const QuickStartCatalogToolbar = ({ children }) => (jsxRuntime.jsx(reactCore.Toolbar, { children: children }));
 
-const QuickStartCloseModal = ({ isOpen, onConfirm, onCancel, }) => {
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(Modal, { isOpen: isOpen, variant: deprecated.ModalVariant.small, showClose: false, "data-test": "leave-quickstart", title: getResource('Leave quick start?'), footer: React__namespace.createElement(reactCore.Flex, null,
-            React__namespace.createElement(reactCore.FlexItem, { align: { default: 'alignRight' } },
-                React__namespace.createElement(reactCore.Button, { variant: "secondary", "data-test": "cancel button", onClick: onCancel }, getResource('Cancel'))),
-            React__namespace.createElement(reactCore.FlexItem, null,
-                React__namespace.createElement(reactCore.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 } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsx(Modal, Object.assign({ isOpen: isOpen, variant: deprecated.ModalVariant.small, showClose: false, "data-test": "leave-quickstart", title: getResource('Leave quick start?'), footer: jsxRuntime.jsxs(reactCore.Flex, { children: [jsxRuntime.jsx(reactCore.FlexItem, Object.assign({ align: { default: 'alignRight' } }, { children: jsxRuntime.jsx(reactCore.Button, Object.assign({ variant: "secondary", "data-test": "cancel button", onClick: onCancel }, { children: getResource('Cancel') })) })), jsxRuntime.jsx(reactCore.FlexItem, { children: jsxRuntime.jsx(reactCore.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__namespace.useRef(null);
-    const { focusOnQuickStart } = React__namespace.useContext(QuickStartContext);
-    React__namespace.useEffect(() => {
+    const titleRef = react.useRef(null);
+    const { focusOnQuickStart } = react.useContext(QuickStartContext);
+    react.useEffect(() => {
         if (focusOnQuickStart && isActiveTask) {
             // Focus the WizardNavItem button element that contains the title
             titleRef.current.parentNode.focus();
         }
     }, [focusOnQuickStart, isActiveTask]);
     const failedReview = taskStatus === exports.QuickStartTaskStatus.FAILED;
-    const tryAgain = failedReview && (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement("div", null),
-        React__namespace.createElement("div", { className: "pfext-quick-start-task-header__tryagain" }, "Try the steps again.")));
-    const content = (React__namespace.createElement("div", { ref: titleRef },
-        React__namespace.createElement(reactCore.Title, { headingLevel: "h3", size: size },
-            React__namespace.createElement("span", { className: "pfext-quick-start-task-header__title" }, title),
-            isActiveTask && subtitle && (React__namespace.createElement("span", null,
-                ' ',
-                React__namespace.createElement("span", { "data-test-id": "quick-start-task-subtitle", className: "pfext-quick-start-task-header__subtitle" }, subtitle))),
-            tryAgain)));
+    const tryAgain = failedReview && (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("div", {}), jsxRuntime.jsx("div", Object.assign({ className: "pfext-quick-start-task-header__tryagain" }, { children: "Try the steps again." }))] }));
+    const content = (jsxRuntime.jsx("div", Object.assign({ ref: titleRef }, { children: jsxRuntime.jsxs(reactCore.Title, Object.assign({ headingLevel: "h3", size: size }, { children: [jsxRuntime.jsx("span", Object.assign({ className: "pfext-quick-start-task-header__title" }, { children: title })), isActiveTask && subtitle && (jsxRuntime.jsxs("span", { children: [' ', jsxRuntime.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 === exports.QuickStartTaskStatus.FAILED) {
         status = 'error';
@@ -1947,42 +1936,31 @@ const QuickStartTaskHeader = ({ title, taskIndex, subtitle, taskStatus, size, is
     else if (taskStatus === exports.QuickStartTaskStatus.SUCCESS) {
         status = 'success';
     }
-    return (React__namespace.createElement(reactCore.WizardNavItem, { content: content, stepIndex: taskIndex, onClick: () => onTaskSelect(taskIndex - 1), component: "button", isCurrent: isActiveTask, status: status, className: "pfext-quick-start-task-header" }, children));
+    return (jsxRuntime.jsx(reactCore.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__namespace.createElement("ul", { className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list" }, tasks.map((task, index) => (React__namespace.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 ? (jsxRuntime.jsx("ul", Object.assign({ className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list" }, { children: tasks.map((task, index) => (jsxRuntime.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(exports.QuickStartTaskStatus.FAILED);
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect }),
-        React__namespace.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__namespace.createElement(reactCore.Button, { variant: "link", onClick: () => onQuickStartChange(nextQuickStart.metadata.name), isInline: true, icon: React__namespace.createElement(ArrowRightIcon__default["default"], 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 } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect }), jsxRuntime.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 (jsxRuntime.jsx(reactCore.Button, Object.assign({ variant: "link", onClick: () => onQuickStartChange(nextQuickStart.metadata.name), isInline: true, icon: jsxRuntime.jsx(ArrowRightIcon__default["default"], {}), 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__namespace.useContext(QuickStartContext);
+    const { getResource } = react.useContext(QuickStartContext);
     const prereqs = prerequisites === null || prerequisites === void 0 ? void 0 : prerequisites.filter((p) => p);
-    const [isPrereqsExpanded, setIsPrereqsExpanded] = React__namespace.useState(false);
-    const prereqList = (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (React__namespace.createElement(reactCore.ExpandableSection, { toggleText: getResource('View Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), onToggle: () => setIsPrereqsExpanded(!isPrereqsExpanded) },
-        React__namespace.createElement(reactCore.List, null, prereqs.map((pr) => (React__namespace.createElement(reactCore.ListItem, { key: pr },
-            React__namespace.createElement(QuickStartMarkdownView, { content: pr })))))));
-    return (React__namespace.createElement(reactCore.Stack, { hasGutter: true },
-        React__namespace.createElement(QuickStartMarkdownView, { content: introduction }),
-        prereqList,
-        React__namespace.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__namespace.createElement(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect })));
+    const [isPrereqsExpanded, setIsPrereqsExpanded] = react.useState(false);
+    const prereqList = (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (jsxRuntime.jsx(reactCore.ExpandableSection, Object.assign({ toggleText: getResource('View Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), onToggle: () => setIsPrereqsExpanded(!isPrereqsExpanded) }, { children: jsxRuntime.jsx(reactCore.List, { children: prereqs.map((pr) => (jsxRuntime.jsx(reactCore.ListItem, { children: jsxRuntime.jsx(QuickStartMarkdownView, { content: pr }) }, pr))) }) })));
+    return (jsxRuntime.jsxs(reactCore.Stack, Object.assign({ hasGutter: true }, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: introduction }), prereqList, jsxRuntime.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), ":"] }), jsxRuntime.jsx(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect })] })));
 };
 
 const getAlertVariant = (status) => {
@@ -1997,64 +1975,52 @@ const getAlertVariant = (status) => {
 };
 const QuickStartTaskReview = ({ review, taskStatus, onTaskReview, }) => {
     const { instructions, failedTaskHelp: taskHelp } = review;
-    const { getResource } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement(reactCore.Alert, { variant: getAlertVariant(taskStatus), title: getResource('Check your work'), isInline: true, role: "alert", style: {
+    const { getResource } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsxs(reactCore.Alert, Object.assign({ variant: getAlertVariant(taskStatus), title: getResource('Check your work'), isInline: true, role: "alert", style: {
             marginBottom: 'var(--pf-t--global--spacer--md)',
-        } },
-        React__namespace.createElement(QuickStartMarkdownView, { content: instructions }),
-        React__namespace.createElement("span", { className: "pfext-quick-start-task-review__actions" },
-            React__namespace.createElement(reactCore.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 === exports.QuickStartTaskStatus.SUCCESS, onChange: () => onTaskReview(exports.QuickStartTaskStatus.SUCCESS) }),
-            React__namespace.createElement(reactCore.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 === exports.QuickStartTaskStatus.FAILED, onChange: () => onTaskReview(exports.QuickStartTaskStatus.FAILED) })),
-        taskStatus === exports.QuickStartTaskStatus.FAILED && taskHelp && (React__namespace.createElement(QuickStartMarkdownView, { content: taskHelp, exactHeight: true }))));
+        } }, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: instructions }), jsxRuntime.jsxs("span", Object.assign({ className: "pfext-quick-start-task-review__actions" }, { children: [jsxRuntime.jsx(reactCore.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 === exports.QuickStartTaskStatus.SUCCESS, onChange: () => onTaskReview(exports.QuickStartTaskStatus.SUCCESS) }), jsxRuntime.jsx(reactCore.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 === exports.QuickStartTaskStatus.FAILED, onChange: () => onTaskReview(exports.QuickStartTaskStatus.FAILED) })] })), taskStatus === exports.QuickStartTaskStatus.FAILED && taskHelp && (jsxRuntime.jsx(QuickStartMarkdownView, { content: taskHelp, exactHeight: true }))] })));
 };
 
 const QuickStartTasks = ({ tasks, taskNumber, allTaskStatuses, onTaskReview, onTaskSelect, }) => {
-    const { getResource, alwaysShowTaskReview } = React__namespace.useContext(QuickStartContext);
-    return (React__namespace.createElement("div", { className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list", style: { padding: '0 0 0 0' } },
-        React__namespace.createElement("ul", null, tasks
-            .filter((_, index) => allTaskStatuses[index] !== exports.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__namespace.createElement(React__namespace.Fragment, { key: title },
-                React__namespace.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__namespace.createElement(reactCore.Stack, { hasGutter: true },
-                    React__namespace.createElement(QuickStartMarkdownView, { content: description }),
-                    shouldShowTaskReview && (React__namespace.createElement(QuickStartTaskReview, { review: review, taskStatus: taskStatus, onTaskReview: onTaskReview })))))));
-        }))));
-};
-
-const QuickStartContent = React__namespace.forwardRef(({ quickStart, nextQuickStarts = [], taskNumber, allTaskStatuses, onTaskSelect, onTaskReview, onQuickStartChange, }, ref) => {
+    const { getResource, alwaysShowTaskReview } = react.useContext(QuickStartContext);
+    return (jsxRuntime.jsx("div", Object.assign({ className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list", style: { padding: '0 0 0 0' } }, { children: jsxRuntime.jsx("ul", { children: tasks
+                .filter((_, index) => allTaskStatuses[index] !== exports.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 (jsxRuntime.jsx(react.Fragment, { children: jsxRuntime.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 && (jsxRuntime.jsxs(reactCore.Stack, Object.assign({ hasGutter: true }, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: description }), shouldShowTaskReview && (jsxRuntime.jsx(QuickStartTaskReview, { review: review, taskStatus: taskStatus, onTaskReview: onTaskReview }))] }))) })) }, title));
+            }) }) })));
+};
+
+const QuickStartContent = react.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__namespace.createElement("div", { className: "pfext-quick-start-task", ref: ref },
-        taskNumber === -1 && (React__namespace.createElement(QuickStartIntroduction, { tasks: tasks, allTaskStatuses: allTaskStatuses, introduction: introduction, prerequisites: prerequisites, onTaskSelect: onTaskSelect })),
-        taskNumber > -1 && taskNumber < totalTasks && (React__namespace.createElement(QuickStartTasks, { tasks: tasks, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskReview: onTaskReview, onTaskSelect: onTaskSelect })),
-        taskNumber === totalTasks && (React__namespace.createElement(QuickStartConclusion, { tasks: tasks, conclusion: conclusion, allTaskStatuses: allTaskStatuses, nextQuickStarts: nextQuickStarts, onQuickStartChange: onQuickStartChange, onTaskSelect: onTaskSelect }))));
+    return (jsxRuntime.jsxs("div", Object.assign({ className: "pfext-quick-start-task", ref: ref }, { children: [taskNumber === -1 && (jsxRuntime.jsx(QuickStartIntroduction, { tasks: tasks, allTaskStatuses: allTaskStatuses, introduction: introduction, prerequisites: prerequisites, onTaskSelect: onTaskSelect })), taskNumber > -1 && taskNumber < totalTasks && (jsxRuntime.jsx(QuickStartTasks, { tasks: tasks, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskReview: onTaskReview, onTaskSelect: onTaskSelect })), taskNumber === totalTasks && (jsxRuntime.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__namespace.useContext(QuickStartContext);
-    const PrimaryButtonText = React__namespace.useMemo(() => ({
+    const { restartQuickStart, getResource } = react.useContext(QuickStartContext);
+    const PrimaryButtonText = react.useMemo(() => ({
         START: getResource('Start'),
         CONTINUE: getResource('Continue'),
         NEXT: getResource('Next'),
         CLOSE: getResource('Close'),
     }), [getResource]);
-    const SecondaryButtonText = React__namespace.useMemo(() => ({
+    const SecondaryButtonText = react.useMemo(() => ({
         BACK: getResource('Back'),
         RESTART: getResource('Restart'),
     }), [getResource]);
-    const onRestart = React__namespace.useCallback((e) => {
+    const onRestart = react.useCallback((e) => {
         e.preventDefault();
         e.stopPropagation();
         restartQuickStart(quickStartId, totalTasks);
     }, [quickStartId, restartQuickStart, totalTasks]);
-    const getPrimaryButtonText = React__namespace.useMemo(() => {
+    const getPrimaryButtonText = react.useMemo(() => {
         if (status === exports.QuickStartStatus.NOT_STARTED) {
             return PrimaryButtonText.START;
         }
@@ -2066,23 +2032,17 @@ const QuickStartFooter = ({ status, taskNumber, totalTasks, onNext, onBack, quic
         }
         return PrimaryButtonText.CONTINUE;
     }, [taskNumber, totalTasks, PrimaryButtonText, status]);
-    const getPrimaryButton = React__namespace.useMemo(() => (React__namespace.createElement(reactCore.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__namespace.useMemo(() => taskNumber === -1 && status !== exports.QuickStartStatus.NOT_STARTED ? (React__namespace.createElement(reactCore.Button, { variant: "secondary", onClick: onRestart, "data-testid": "qs-drawer-restart" }, SecondaryButtonText.RESTART)) : (taskNumber > -1 && (React__namespace.createElement(reactCore.Button, { variant: "secondary", onClick: onBack, "data-testid": "qs-drawer-back" }, SecondaryButtonText.BACK))), [onRestart, onBack, SecondaryButtonText, status, taskNumber]);
-    const getSideNoteAction = React__namespace.useMemo(() => taskNumber !== -1 && (React__namespace.createElement(reactCore.Button, { variant: "link", onClick: onRestart, "data-testid": "qs-drawer-side-note-action" }, SecondaryButtonText.RESTART)), [taskNumber, onRestart, SecondaryButtonText.RESTART]);
-    return (React__namespace.createElement("div", { className: reactStyles.css('pfext-quick-start-footer', className) },
-        React__namespace.createElement(reactCore.ActionList, null,
-            React__namespace.createElement(reactCore.ActionListGroup, null,
-                React__namespace.createElement(reactCore.ActionListItem, null, getPrimaryButton),
-                React__namespace.createElement(reactCore.ActionListItem, null, getSecondaryButton)),
-            React__namespace.createElement(reactCore.ActionListGroup, null,
-                React__namespace.createElement(reactCore.ActionListItem, null, getSideNoteAction)))));
+    const getPrimaryButton = react.useMemo(() => (jsxRuntime.jsx(reactCore.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 = react.useMemo(() => taskNumber === -1 && status !== exports.QuickStartStatus.NOT_STARTED ? (jsxRuntime.jsx(reactCore.Button, Object.assign({ variant: "secondary", onClick: onRestart, "data-testid": "qs-drawer-restart" }, { children: SecondaryButtonText.RESTART }))) : (taskNumber > -1 && (jsxRuntime.jsx(reactCore.Button, Object.assign({ variant: "secondary", onClick: onBack, "data-testid": "qs-drawer-back" }, { children: SecondaryButtonText.BACK })))), [onRestart, onBack, SecondaryButtonText, status, taskNumber]);
+    const getSideNoteAction = react.useMemo(() => taskNumber !== -1 && (jsxRuntime.jsx(reactCore.Button, Object.assign({ variant: "link", onClick: onRestart, "data-testid": "qs-drawer-side-note-action" }, { children: SecondaryButtonText.RESTART }))), [taskNumber, onRestart, SecondaryButtonText.RESTART]);
+    return (jsxRuntime.jsx("div", Object.assign({ className: reactStyles.css('pfext-quick-start-footer', className) }, { children: jsxRuntime.jsxs(reactCore.ActionList, { children: [jsxRuntime.jsxs(reactCore.ActionListGroup, { children: [jsxRuntime.jsx(reactCore.ActionListItem, { children: getPrimaryButton }), jsxRuntime.jsx(reactCore.ActionListItem, { children: getSecondaryButton })] }), jsxRuntime.jsx(reactCore.ActionListGroup, { children: jsxRuntime.jsx(reactCore.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__namespace.useContext(QuickStartContext);
-    React__namespace.useEffect(() => {
+    const { activeQuickStartID, allQuickStartStates, setAllQuickStartStates, activeQuickStartState, setActiveQuickStart, setQuickStartTaskNumber, setQuickStartTaskStatus, nextStep, previousStep, } = react.useContext(QuickStartContext);
+    react.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() }));
@@ -2091,9 +2051,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__namespace.useCallback((quickStartId) => setActiveQuickStart(quickStartId), [setActiveQuickStart]);
-    const handleTaskStatusChange = React__namespace.useCallback((newTaskStatus) => setQuickStartTaskStatus(newTaskStatus), [setQuickStartTaskStatus]);
-    const getQuickStartActiveTask = React__namespace.useCallback(() => {
+    const handleQuickStartChange = react.useCallback((quickStartId) => setActiveQuickStart(quickStartId), [setActiveQuickStart]);
+    const handleTaskStatusChange = react.useCallback((newTaskStatus) => setQuickStartTaskStatus(newTaskStatus), [setQuickStartTaskStatus]);
+    const getQuickStartActiveTask = react.useCallback(() => {
         let activeTaskNumber = 0;
         while (activeTaskNumber !== totalTasks &&
             activeQuickStartState[`taskStatus${activeTaskNumber}`] === exports.QuickStartTaskStatus.SUCCESS) {
@@ -2101,11 +2061,11 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
         }
         return activeTaskNumber;
     }, [totalTasks, activeQuickStartState]);
-    const handleQuickStartContinue = React__namespace.useCallback(() => {
+    const handleQuickStartContinue = react.useCallback(() => {
         const activeTaskNumber = getQuickStartActiveTask();
         setQuickStartTaskNumber(name, activeTaskNumber);
     }, [getQuickStartActiveTask, setQuickStartTaskNumber, name]);
-    const handleNext = React__namespace.useCallback(() => {
+    const handleNext = react.useCallback(() => {
         if (status === exports.QuickStartStatus.COMPLETE && taskNumber === totalTasks) {
             return handleQuickStartChange('');
         }
@@ -2114,13 +2074,11 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
         }
         return nextStep(totalTasks);
     }, [handleQuickStartChange, nextStep, status, taskNumber, totalTasks, handleQuickStartContinue]);
-    const handleBack = React__namespace.useCallback(() => previousStep(), [previousStep]);
-    const handleTaskSelect = React__namespace.useCallback((selectedTaskNumber) => {
+    const handleBack = react.useCallback(() => previousStep(), [previousStep]);
+    const handleTaskSelect = react.useCallback((selectedTaskNumber) => {
         setQuickStartTaskNumber(name, selectedTaskNumber);
     }, [name, setQuickStartTaskNumber]);
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement(QuickStartContent, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskSelect: handleTaskSelect, onTaskReview: handleTaskStatusChange, onQuickStartChange: handleQuickStartChange, ref: contentRef }),
-        React__namespace.createElement(QuickStartFooter, { status: status, taskNumber: taskNumber, totalTasks: totalTasks, onNext: handleNext, onBack: handleBack, className: footerClass, quickStartId: quickStart.metadata.name })));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(QuickStartContent, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskSelect: handleTaskSelect, onTaskReview: handleTaskStatusChange, onQuickStartChange: handleQuickStartChange, ref: contentRef }), jsxRuntime.jsx(QuickStartFooter, { status: status, taskNumber: taskNumber, totalTasks: totalTasks, onNext: handleNext, onBack: handleBack, className: footerClass, quickStartId: quickStart.metadata.name })] }));
 };
 
 const getElement = (appendTo) => {
@@ -2130,7 +2088,7 @@ const getElement = (appendTo) => {
     return appendTo;
 };
 const useScrollTopOnTaskNumberChange = (node, taskNumber) => {
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (node) {
             node.scrollTo({ top: 0, behavior: 'smooth' });
         }
@@ -2138,9 +2096,9 @@ const useScrollTopOnTaskNumberChange = (node, taskNumber) => {
 };
 const QuickStartPanelContent = (_a) => {
     var { quickStarts = [], handleClose, activeQuickStartID, appendTo, isResizable = true, showClose = true, footerClass } = _a, props = tslib.__rest(_a, ["quickStarts", "handleClose", "activeQuickStartID", "appendTo", "isResizable", "showClose", "footerClass"]);
-    const titleRef = React__namespace.useRef(null);
-    const { getResource, activeQuickStartState, focusOnQuickStart } = React__namespace.useContext(QuickStartContext);
-    const [contentRef, setContentRef] = React__namespace.useState();
+    const titleRef = react.useRef(null);
+    const { getResource, activeQuickStartState, focusOnQuickStart } = react.useContext(QuickStartContext);
+    const [contentRef, setContentRef] = react.useState();
     const quickStart = quickStarts.find((qs) => qs.metadata.name === activeQuickStartID);
     const taskNumber = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.taskNumber;
     useScrollTopOnTaskNumberChange(contentRef, taskNumber);
@@ -2156,27 +2114,16 @@ const QuickStartPanelContent = (_a) => {
         }
         return Number.parseInt(taskNumber) + 1;
     };
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (focusOnQuickStart && quickStart) {
             titleRef.current.focus();
         }
     }, [focusOnQuickStart, quickStart]);
-    const content = quickStart ? (React__namespace.createElement(reactCore.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__namespace.createElement("div", { className: "pfext-quick-start-panel-content" },
-            React__namespace.createElement(reactCore.DrawerHead, null,
-                React__namespace.createElement("div", { tabIndex: -1, ref: titleRef },
-                    React__namespace.createElement(reactCore.Title, { headingLevel: "h2", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } },
-                        React__namespace.createElement("span", null, quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.displayName),
-                        ' '),
-                    React__namespace.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__namespace.createElement(reactCore.DrawerActions, null,
-                    React__namespace.createElement(reactCore.DrawerCloseButton, { onClick: handleClose, className: "pfext-quick-start-panel-content__close-button", "data-testid": "qs-drawer-close" }))))),
-        React__namespace.createElement(reactCore.DrawerPanelBody, { className: "pfext-quick-start-panel-content__body", "data-test": "content" },
-            React__namespace.createElement(QuickStartController, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, footerClass: footerClass, contentRef: setContentRef })))) : null;
+    const content = quickStart ? (jsxRuntime.jsxs(reactCore.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: [jsxRuntime.jsx("div", Object.assign({ className: "pfext-quick-start-panel-content" }, { children: jsxRuntime.jsxs(reactCore.DrawerHead, { children: [jsxRuntime.jsxs("div", Object.assign({ tabIndex: -1, ref: titleRef }, { children: [jsxRuntime.jsxs(reactCore.Title, Object.assign({ headingLevel: "h2", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, { children: [jsxRuntime.jsx("span", { children: quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.displayName }), ' '] })), jsxRuntime.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 && (jsxRuntime.jsx(reactCore.DrawerActions, { children: jsxRuntime.jsx(reactCore.DrawerCloseButton, { onClick: handleClose, className: "pfext-quick-start-panel-content__close-button", "data-testid": "qs-drawer-close" }) }))] }) })), jsxRuntime.jsx(reactCore.DrawerPanelBody, Object.assign({ className: "pfext-quick-start-panel-content__body", "data-test": "content" }, { children: jsxRuntime.jsx(QuickStartController, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, footerClass: footerClass, contentRef: setContentRef }) }))] }))) : null;
     if (appendTo) {
         return ReactDOM__namespace.createPortal(content, getElement(appendTo));
     }
@@ -2185,8 +2132,8 @@ const QuickStartPanelContent = (_a) => {
 
 const QuickStartDrawerContent = (_a) => {
     var { quickStarts = [], appendTo, fullWidth, handleDrawerClose } = _a, props = tslib.__rest(_a, ["quickStarts", "appendTo", "fullWidth", "handleDrawerClose"]);
-    const { activeQuickStartID, allQuickStarts = [], activeQuickStartState, } = React__namespace.useContext(QuickStartContext);
-    const combinedQuickStarts = allQuickStarts.concat(quickStarts);
+    const { activeQuickStartID, allQuickStarts = [], activeQuickStartState, } = react.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);
     };
@@ -2197,14 +2144,14 @@ const QuickStartDrawerContent = (_a) => {
             },
         }
         : {};
-    return (React__namespace.createElement(QuickStartPanelContent, Object.assign({ quickStarts: combinedQuickStarts, handleClose: handleClose, activeQuickStartID: activeQuickStartID, appendTo: appendTo, isResizable: !fullWidth }, fullWidthPanelStyle, props)));
+    return (jsxRuntime.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 = tslib.__rest(_a, ["quickStarts", "children", "appendTo", "fullWidth", "onCloseInProgress", "onCloseNotInProgress"]);
-    const { activeQuickStartID, setActiveQuickStart, allQuickStarts = [], allQuickStartStates, setAllQuickStartStates, } = React__namespace.useContext(QuickStartContext);
+    const { activeQuickStartID, setActiveQuickStart, allQuickStarts = [], allQuickStartStates, setAllQuickStartStates, } = react.useContext(QuickStartContext);
     const combinedQuickStarts = allQuickStarts.concat(quickStarts);
-    React__namespace.useEffect(() => {
+    react.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
@@ -2217,13 +2164,13 @@ const QuickStartDrawer = (_a) => {
             }
         }
     }, [activeQuickStartID, combinedQuickStarts, setActiveQuickStart]);
-    React__namespace.useEffect(() => {
+    react.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__namespace.useState(false);
+    const [modalOpen, setModalOpen] = react.useState(false);
     const onClose = () => setActiveQuickStart('');
     const handleClose = (activeQuickStartStatus) => {
         if (activeQuickStartStatus === exports.QuickStartStatus.IN_PROGRESS) {
@@ -2253,11 +2200,7 @@ const QuickStartDrawer = (_a) => {
             },
         }
         : {};
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement(reactCore.Drawer, Object.assign({ isExpanded: !!activeQuickStartID, isInline: true }, props),
-            React__namespace.createElement(reactCore.DrawerContent, Object.assign({ panelContent: React__namespace.createElement(QuickStartDrawerContent, { quickStarts: combinedQuickStarts, handleDrawerClose: handleClose, appendTo: appendTo, fullWidth: fullWidth }) }, fullWidthBodyStyle),
-                React__namespace.createElement(reactCore.DrawerContentBody, null, children))),
-        React__namespace.createElement(QuickStartCloseModal, { isOpen: modalOpen, onConfirm: onModalConfirm, onCancel: onModalCancel })));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(reactCore.Drawer, Object.assign({ isExpanded: !!activeQuickStartID, isInline: true }, props, { children: jsxRuntime.jsx(reactCore.DrawerContent, Object.assign({ panelContent: jsxRuntime.jsx(QuickStartDrawerContent, { quickStarts: combinedQuickStarts, handleDrawerClose: handleClose, appendTo: appendTo, fullWidth: fullWidth }) }, fullWidthBodyStyle, { children: jsxRuntime.jsx(reactCore.DrawerContentBody, { children: children }) })) })), jsxRuntime.jsx(QuickStartCloseModal, { isOpen: modalOpen, onConfirm: onModalConfirm, onCancel: onModalCancel })] }));
 };
 
 const QuickStartContainer = (_a) => {
@@ -2272,13 +2215,13 @@ const QuickStartContainer = (_a) => {
         useQueryParams,
         markdown,
         alwaysShowTaskReview }, contextProps));
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (quickStarts &&
             JSON.stringify(quickStarts) !== JSON.stringify(valuesForQuickstartContext.allQuickStarts)) {
             valuesForQuickstartContext.setAllQuickStarts(quickStarts);
         }
     }, [quickStarts, valuesForQuickstartContext]);
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (loading !== valuesForQuickstartContext.loading) {
             valuesForQuickstartContext.setLoading(loading);
         }
@@ -2287,7 +2230,7 @@ const QuickStartContainer = (_a) => {
         fullWidth,
         onCloseInProgress,
         onCloseNotInProgress }, props);
-    return (React__namespace.createElement(QuickStartContext.Provider, { value: valuesForQuickstartContext }, isManagedDrawer ? (React__namespace.createElement(QuickStartDrawer, Object.assign({}, drawerProps), children)) : (children)));
+    return (jsxRuntime.jsx(QuickStartContext.Provider, Object.assign({ value: valuesForQuickstartContext }, { children: isManagedDrawer ? (jsxRuntime.jsx(QuickStartDrawer, Object.assign({}, drawerProps, { children: children }))) : (children) })));
 };
 
 const HelpTopicContextDefaults = {
@@ -2299,14 +2242,14 @@ const HelpTopicContextDefaults = {
     setFilteredHelpTopics: () => { },
     loading: false,
 };
-const HelpTopicContext = React__default["default"].createContext(HelpTopicContextDefaults);
+const HelpTopicContext = react.createContext(HelpTopicContextDefaults);
 const useValuesForHelpTopicContext = (value = {}) => {
     const combinedValue = Object.assign(Object.assign({}, HelpTopicContextDefaults), value);
-    const [loading, setLoading] = React__default["default"].useState(combinedValue.loading);
+    const [loading, setLoading] = react.useState(combinedValue.loading);
     // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    const [helpTopics, setHelpTopics] = React__default["default"].useState(combinedValue.helpTopics || []);
-    const [activeHelpTopic, setActiveHelpTopic] = React__default["default"].useState(combinedValue.activeHelpTopic || null);
-    const setActiveHelpTopicByName = React__default["default"].useCallback((helpTopicName) => {
+    const [helpTopics, setHelpTopics] = react.useState(combinedValue.helpTopics || []);
+    const [activeHelpTopic, setActiveHelpTopic] = react.useState(combinedValue.activeHelpTopic || null);
+    const setActiveHelpTopicByName = react.useCallback((helpTopicName) => {
         const topic = helpTopics.find((t) => t.name === helpTopicName);
         if (!helpTopicName) {
             setActiveHelpTopic(null);
@@ -2314,7 +2257,7 @@ const useValuesForHelpTopicContext = (value = {}) => {
         }
         setActiveHelpTopic(topic);
     }, [helpTopics]);
-    const [filteredHelpTopics, setFilteredHelpTopics] = React__default["default"].useState(combinedValue.filteredHelpTopics || []);
+    const [filteredHelpTopics, setFilteredHelpTopics] = react.useState(combinedValue.filteredHelpTopics || []);
     return {
         helpTopics,
         setHelpTopics,
@@ -2330,8 +2273,8 @@ const useValuesForHelpTopicContext = (value = {}) => {
 const HelpTopicPanelContent = (_a) => {
     var _b, _c;
     var { activeHelpTopic = null, filteredHelpTopics = [], isResizable = true, onClose } = _a, props = tslib.__rest(_a, ["activeHelpTopic", "filteredHelpTopics", "isResizable", "onClose"]);
-    const { setActiveHelpTopicByName } = React__namespace.useContext(HelpTopicContext);
-    const [isHelpTopicMenuOpen, setIsHelpTopicMenuOpen] = React__namespace.useState(false);
+    const { setActiveHelpTopicByName } = react.useContext(HelpTopicContext);
+    const [isHelpTopicMenuOpen, setIsHelpTopicMenuOpen] = react.useState(false);
     const toggleHelpTopicMenu = () => {
         setIsHelpTopicMenuOpen(!isHelpTopicMenuOpen);
     };
@@ -2341,24 +2284,10 @@ const HelpTopicPanelContent = (_a) => {
         toggleHelpTopicMenu();
     };
     const helpTopicOptions = filteredHelpTopics.length > 1 &&
-        filteredHelpTopics.map((topic) => (React__namespace.createElement(reactCore.SelectOption, { key: topic.name, value: topic.name }, topic.title)));
-    const paddingContainer = (children) => React__namespace.createElement("div", { style: { padding: '24px' } }, children);
-    const panelBodyItems = (React__namespace.createElement(React__namespace.Fragment, null,
-        paddingContainer(React__namespace.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__namespace.createElement(reactCore.Divider, null),
-        paddingContainer(React__namespace.createElement(reactCore.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__namespace.createElement(reactCore.StackItem, { key: index },
-            React__namespace.createElement(reactCore.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__namespace.createElement(ExternalLinkAltIcon__default["default"], null) : null, iconPosition: "right", style: { fontSize: 'inherit' } }, text || href))))))));
-    const content = (React__namespace.createElement(reactCore.DrawerPanelContent, Object.assign({ isResizable: isResizable }, props),
-        React__namespace.createElement("div", null,
-            React__namespace.createElement(reactCore.DrawerHead, null,
-                React__namespace.createElement("div", null,
-                    helpTopicOptions && (React__namespace.createElement(reactCore.Select, { isPlain: true, id: "help-topics-select", selected: activeHelpTopic, isOpen: isHelpTopicMenuOpen, onSelect: onSelectHelpTopic, onOpenChange: (isOpen) => setIsHelpTopicMenuOpen(isOpen), toggle: (toggleRef) => (React__namespace.createElement(reactCore.MenuToggle, { isFullWidth: true, ref: toggleRef, icon: React__namespace.createElement(BarsIcon__default["default"], null), onClick: toggleHelpTopicMenu, isExpanded: isHelpTopicMenuOpen }, activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title)) },
-                        React__namespace.createElement(reactCore.SelectList, null, helpTopicOptions))),
-                    React__namespace.createElement(reactCore.Title, { headingLevel: "h1", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title)),
-                React__namespace.createElement(reactCore.DrawerActions, null,
-                    React__namespace.createElement(reactCore.DrawerCloseButton, { onClick: onClose, "data-testid": "qs-drawer-close" }))),
-            React__namespace.createElement(reactCore.Divider, null),
-            React__namespace.createElement(reactCore.DrawerPanelBody, { "data-test": "content" }, panelBodyItems))));
+        filteredHelpTopics.map((topic) => (jsxRuntime.jsx(reactCore.SelectOption, Object.assign({ value: topic.name }, { children: topic.title }), topic.name)));
+    const paddingContainer = (children) => jsxRuntime.jsx("div", Object.assign({ style: { padding: '24px' } }, { children: children }));
+    const panelBodyItems = (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [paddingContainer(jsxRuntime.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) && jsxRuntime.jsx(reactCore.Divider, {}), paddingContainer(jsxRuntime.jsx(reactCore.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) => (jsxRuntime.jsx(reactCore.StackItem, { children: jsxRuntime.jsx(reactCore.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 ? jsxRuntime.jsx(ExternalLinkAltIcon__default["default"], {}) : null, iconPosition: "right", style: { fontSize: 'inherit' } }, { children: text || href })) }, index))) })))] }));
+    const content = (jsxRuntime.jsx(reactCore.DrawerPanelContent, Object.assign({ isResizable: isResizable }, props, { children: jsxRuntime.jsxs("div", { children: [jsxRuntime.jsxs(reactCore.DrawerHead, { children: [jsxRuntime.jsxs("div", { children: [helpTopicOptions && (jsxRuntime.jsx(reactCore.Select, Object.assign({ isPlain: true, id: "help-topics-select", selected: activeHelpTopic, isOpen: isHelpTopicMenuOpen, onSelect: onSelectHelpTopic, onOpenChange: (isOpen) => setIsHelpTopicMenuOpen(isOpen), toggle: (toggleRef) => (jsxRuntime.jsx(reactCore.MenuToggle, Object.assign({ isFullWidth: true, ref: toggleRef, icon: jsxRuntime.jsx(BarsIcon__default["default"], {}), onClick: toggleHelpTopicMenu, isExpanded: isHelpTopicMenuOpen }, { children: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title }))) }, { children: jsxRuntime.jsx(reactCore.SelectList, { children: helpTopicOptions }) }))), jsxRuntime.jsx(reactCore.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 }))] }), jsxRuntime.jsx(reactCore.DrawerActions, { children: jsxRuntime.jsx(reactCore.DrawerCloseButton, { onClick: onClose, "data-testid": "qs-drawer-close" }) })] }), jsxRuntime.jsx(reactCore.Divider, {}), jsxRuntime.jsx(reactCore.DrawerPanelBody, Object.assign({ "data-test": "content" }, { children: panelBodyItems }))] }) })));
     return content;
 };
 
@@ -2367,36 +2296,33 @@ const HelpTopicContainer = (_a) => {
     const valuesForHelpTopicContext = useValuesForHelpTopicContext(Object.assign({ helpTopics,
         language, resourceBundle: Object.assign({}, resourceBundle), loading,
         markdown }, contextProps));
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (loading !== valuesForHelpTopicContext.loading) {
             valuesForHelpTopicContext.setLoading(loading);
         }
     }, [loading, valuesForHelpTopicContext]);
-    React__namespace.useEffect(() => {
+    react.useEffect(() => {
         if (helpTopics &&
             JSON.stringify(helpTopics) !== JSON.stringify(valuesForHelpTopicContext.helpTopics)) {
             valuesForHelpTopicContext.setHelpTopics(helpTopics);
         }
     }, [helpTopics, valuesForHelpTopicContext]);
-    return (React__namespace.createElement(HelpTopicContext.Provider, { value: valuesForHelpTopicContext },
-        React__namespace.createElement(HelpTopicDrawer, Object.assign({}, props), children)));
+    return (jsxRuntime.jsx(HelpTopicContext.Provider, Object.assign({ value: valuesForHelpTopicContext }, { children: jsxRuntime.jsx(HelpTopicDrawer, Object.assign({}, props, { children: children })) })));
 };
 const HelpTopicDrawer = (_a) => {
     var { children } = _a, props = tslib.__rest(_a, ["children"]);
-    const { activeHelpTopic, filteredHelpTopics, setActiveHelpTopicByName } = React__namespace.useContext(HelpTopicContext);
+    const { activeHelpTopic, filteredHelpTopics, setActiveHelpTopicByName } = react.useContext(HelpTopicContext);
     const onClose = () => {
         setActiveHelpTopicByName('');
     };
-    const panelContent = (React__namespace.createElement(HelpTopicPanelContent, { activeHelpTopic: activeHelpTopic, filteredHelpTopics: filteredHelpTopics, onClose: onClose }));
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement(reactCore.Drawer, Object.assign({ isExpanded: !!activeHelpTopic, isInline: true }, props), children ? (React__namespace.createElement(reactCore.DrawerContent, { panelContent: panelContent },
-            React__namespace.createElement(reactCore.DrawerContentBody, null, children))) : (React__namespace.createElement("div", { className: "pf-v6-c-drawer__main" }, panelContent)))));
+    const panelContent = (jsxRuntime.jsx(HelpTopicPanelContent, { activeHelpTopic: activeHelpTopic, filteredHelpTopics: filteredHelpTopics, onClose: onClose }));
+    return (jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxRuntime.jsx(reactCore.Drawer, Object.assign({ isExpanded: !!activeHelpTopic, isInline: true }, props, { children: children ? (jsxRuntime.jsx(reactCore.DrawerContent, Object.assign({ panelContent: panelContent }, { children: jsxRuntime.jsx(reactCore.DrawerContentBody, { children: children }) }))) : (jsxRuntime.jsx("div", Object.assign({ className: "pf-v6-c-drawer__main" }, { children: panelContent }))) })) }));
 };
 
 const useLocalStorage = (key, initialValue) => {
     // State to store our value
     // Pass initial state function to useState so logic is only executed once
-    const [storedValue, setStoredValue] = React.useState(() => {
+    const [storedValue, setStoredValue] = react.useState(() => {
         try {
             // Get from local storage by key
             const item = window.localStorage.getItem(key);