@patternfly/quickstarts 6.3.0-prerelease.3 → 6.3.0-prerelease.4

package/dist/quickstarts-full.es.js

@@ -1,9 +1,1376 @@
 import * as React from 'react';
-import React__default, { useRef, useEffect, forwardRef, useImperativeHandle, useMemo, useState, createContext, useCallback } from 'react';
+import React__default, { useRef, useEffect, forwardRef, useImperativeHandle, useMemo, useState, createContext, useCallback, useContext, Fragment as Fragment$1, useReducer, cloneElement, Children } from 'react';
 import * as ReactDOM from 'react-dom';
+import { createPortal } from 'react-dom';
 import fa$1 from 'stream';
 import aa from 'util';
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+	return fn(module, module.exports), module.exports;
+}
+
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var k$1=Symbol.for("react.element"),l$2=Symbol.for("react.fragment"),m$1=Object.prototype.hasOwnProperty,n$1=React__default.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
+function q$2(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m$1.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return {$$typeof:k$1,type:c,key:e,ref:h,props:d,_owner:n$1.current}}var Fragment=l$2;var jsx=q$2;var jsxs=q$2;
+
+var reactJsxRuntime_production_min = {
+	Fragment: Fragment,
+	jsx: jsx,
+	jsxs: jsxs
+};
+
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var reactJsxRuntime_development = createCommonjsModule(function (module, exports) {
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+var React = React__default;
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+var REACT_MEMO_TYPE = Symbol.for('react.memo');
+var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+var FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function error(format) {
+  {
+    {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      printWarning('error', format, args);
+    }
+  }
+}
+
+function printWarning(level, format, args) {
+  // When changing this logic, you might want to also
+  // update consoleWithStackDev.www.js as well.
+  {
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+    if (stack !== '') {
+      format += '%s';
+      args = args.concat([stack]);
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    var argsWithFormat = args.map(function (item) {
+      return String(item);
+    }); // Careful: RN currently depends on this prefix
+
+    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+    // breaks IE9: https://github.com/facebook/react/issues/13610
+    // eslint-disable-next-line react-internal/no-production-logging
+
+    Function.prototype.apply.call(console[level], console, argsWithFormat);
+  }
+}
+
+// -----------------------------------------------------------------------------
+
+var enableScopeAPI = false; // Experimental Create Event Handle API.
+var enableCacheElement = false;
+var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+// stuff. Intended to enable React core members to more easily debug scheduling
+// issues in DEV builds.
+
+var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+var REACT_MODULE_REFERENCE;
+
+{
+  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+}
+
+function isValidElementType(type) {
+  if (typeof type === 'string' || typeof type === 'function') {
+    return true;
+  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+    return true;
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+    // types supported by any Flight configuration anywhere since
+    // we don't know which Flight build this will end up being used
+    // with.
+    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function getWrappedName(outerType, innerType, wrapperName) {
+  var displayName = outerType.displayName;
+
+  if (displayName) {
+    return displayName;
+  }
+
+  var functionName = innerType.displayName || innerType.name || '';
+  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+} // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  {
+    if (typeof type.tag === 'number') {
+      error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+    }
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        var context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        var provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        var outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          var lazyComponent = type;
+          var payload = lazyComponent._payload;
+          var init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      // eslint-disable-next-line no-fallthrough
+    }
+  }
+
+  return null;
+}
+
+var assign = Object.assign;
+
+// Helpers to patch console.logs to avoid logging during side-effect free
+// replaying on render function. This currently only patches the object
+// lazily which won't cover if the log function was extracted eagerly.
+// We could also eagerly patch the method.
+var disabledDepth = 0;
+var prevLog;
+var prevInfo;
+var prevWarn;
+var prevError;
+var prevGroup;
+var prevGroupCollapsed;
+var prevGroupEnd;
+
+function disabledLog() {}
+
+disabledLog.__reactDisabledLog = true;
+function disableLogs() {
+  {
+    if (disabledDepth === 0) {
+      /* eslint-disable react-internal/no-production-logging */
+      prevLog = console.log;
+      prevInfo = console.info;
+      prevWarn = console.warn;
+      prevError = console.error;
+      prevGroup = console.group;
+      prevGroupCollapsed = console.groupCollapsed;
+      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+      var props = {
+        configurable: true,
+        enumerable: true,
+        value: disabledLog,
+        writable: true
+      }; // $FlowFixMe Flow thinks console is immutable.
+
+      Object.defineProperties(console, {
+        info: props,
+        log: props,
+        warn: props,
+        error: props,
+        group: props,
+        groupCollapsed: props,
+        groupEnd: props
+      });
+      /* eslint-enable react-internal/no-production-logging */
+    }
+
+    disabledDepth++;
+  }
+}
+function reenableLogs() {
+  {
+    disabledDepth--;
+
+    if (disabledDepth === 0) {
+      /* eslint-disable react-internal/no-production-logging */
+      var props = {
+        configurable: true,
+        enumerable: true,
+        writable: true
+      }; // $FlowFixMe Flow thinks console is immutable.
+
+      Object.defineProperties(console, {
+        log: assign({}, props, {
+          value: prevLog
+        }),
+        info: assign({}, props, {
+          value: prevInfo
+        }),
+        warn: assign({}, props, {
+          value: prevWarn
+        }),
+        error: assign({}, props, {
+          value: prevError
+        }),
+        group: assign({}, props, {
+          value: prevGroup
+        }),
+        groupCollapsed: assign({}, props, {
+          value: prevGroupCollapsed
+        }),
+        groupEnd: assign({}, props, {
+          value: prevGroupEnd
+        })
+      });
+      /* eslint-enable react-internal/no-production-logging */
+    }
+
+    if (disabledDepth < 0) {
+      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+    }
+  }
+}
+
+var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+var prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        var match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+var reentry = false;
+var componentFrameCache;
+
+{
+  var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+  componentFrameCache = new PossiblyWeakMap();
+}
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if ( !fn || reentry) {
+    return '';
+  }
+
+  {
+    var frame = componentFrameCache.get(fn);
+
+    if (frame !== undefined) {
+      return frame;
+    }
+  }
+
+  var control;
+  reentry = true;
+  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  var previousDispatcher;
+
+  {
+    previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
+    // for warnings.
+
+    ReactCurrentDispatcher.current = null;
+    disableLogs();
+  }
+
+  try {
+    // This should throw.
+    if (construct) {
+      // Something should be setting the props in the constructor.
+      var Fake = function () {
+        throw Error();
+      }; // $FlowFixMe
+
+
+      Object.defineProperty(Fake.prototype, 'props', {
+        set: function () {
+          // We use a throwing setter instead of frozen or non-writable props
+          // because that won't throw in a non-strict mode function.
+          throw Error();
+        }
+      });
+
+      if (typeof Reflect === 'object' && Reflect.construct) {
+        // We construct a different control for this case to include any extra
+        // frames added by the construct call.
+        try {
+          Reflect.construct(Fake, []);
+        } catch (x) {
+          control = x;
+        }
+
+        Reflect.construct(fn, [], Fake);
+      } else {
+        try {
+          Fake.call();
+        } catch (x) {
+          control = x;
+        }
+
+        fn.call(Fake.prototype);
+      }
+    } else {
+      try {
+        throw Error();
+      } catch (x) {
+        control = x;
+      }
+
+      fn();
+    }
+  } catch (sample) {
+    // This is inlined manually because closure doesn't do it for us.
+    if (sample && control && typeof sample.stack === 'string') {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      var sampleLines = sample.stack.split('\n');
+      var controlLines = control.stack.split('\n');
+      var s = sampleLines.length - 1;
+      var c = controlLines.length - 1;
+
+      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+        // We expect at least one stack frame to be shared.
+        // Typically this will be the root most one. However, stack frames may be
+        // cut off due to maximum stack limits. In this case, one maybe cut off
+        // earlier than the other. We assume that the sample is longer or the same
+        // and there for cut off earlier. So we should find the root most frame in
+        // the sample somewhere in the control.
+        c--;
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                // but we have a user-provided "displayName"
+                // splice it in to make the stack more readable.
+
+
+                if (fn.displayName && _frame.includes('<anonymous>')) {
+                  _frame = _frame.replace('<anonymous>', fn.displayName);
+                }
+
+                {
+                  if (typeof fn === 'function') {
+                    componentFrameCache.set(fn, _frame);
+                  }
+                } // Return the line we found.
+
+
+                return _frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    {
+      ReactCurrentDispatcher.current = previousDispatcher;
+      reenableLogs();
+    }
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  var name = fn ? fn.displayName || fn.name : '';
+  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  {
+    if (typeof fn === 'function') {
+      componentFrameCache.set(fn, syntheticFrame);
+    }
+  }
+
+  return syntheticFrame;
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function shouldConstruct(Component) {
+  var prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+
+  if (type == null) {
+    return '';
+  }
+
+  if (typeof type === 'function') {
+    {
+      return describeNativeComponentFrame(type, shouldConstruct(type));
+    }
+  }
+
+  if (typeof type === 'string') {
+    return describeBuiltInComponentFrame(type);
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return describeBuiltInComponentFrame('SuspenseList');
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeFunctionComponentFrame(type.render);
+
+      case REACT_MEMO_TYPE:
+        // Memo may contain any component type so we recursively resolve it.
+        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+
+      case REACT_LAZY_TYPE:
+        {
+          var lazyComponent = type;
+          var payload = lazyComponent._payload;
+          var init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var loggedTypeFailures = {};
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
+function setCurrentlyValidatingElement(element) {
+  {
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+      ReactDebugCurrentFrame.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame.setExtraStackFrame(null);
+    }
+  }
+}
+
+function checkPropTypes(typeSpecs, values, location, componentName, element) {
+  {
+    // $FlowFixMe This is okay but Flow doesn't know it.
+    var has = Function.call.bind(hasOwnProperty);
+
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
+
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== 'function') {
+            // eslint-disable-next-line react-internal/prod-error-codes
+            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+            err.name = 'Invariant Violation';
+            throw err;
+          }
+
+          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
+        } catch (ex) {
+          error$1 = ex;
+        }
+
+        if (error$1 && !(error$1 instanceof Error)) {
+          setCurrentlyValidatingElement(element);
+
+          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
+
+          setCurrentlyValidatingElement(null);
+        }
+
+        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error$1.message] = true;
+          setCurrentlyValidatingElement(element);
+
+          error('Failed %s type: %s', location, error$1.message);
+
+          setCurrentlyValidatingElement(null);
+        }
+      }
+    }
+  }
+}
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+/*
+ * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
+ * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+ *
+ * The functions in this module will throw an easier-to-understand,
+ * easier-to-debug exception with a clear errors message message explaining the
+ * problem. (Instead of a confusing exception thrown inside the implementation
+ * of the `value` object).
+ */
+// $FlowFixMe only called in DEV, so void return is not possible.
+function typeName(value) {
+  {
+    // toStringTag is needed for namespaced types like Temporal.Instant
+    var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+    var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
+    return type;
+  }
+} // $FlowFixMe only called in DEV, so void return is not possible.
+
+
+function willCoercionThrow(value) {
+  {
+    try {
+      testStringCoercion(value);
+      return false;
+    } catch (e) {
+      return true;
+    }
+  }
+}
+
+function testStringCoercion(value) {
+  // If you ended up here by following an exception call stack, here's what's
+  // happened: you supplied an object or symbol value to React (as a prop, key,
+  // DOM attribute, CSS property, string ref, etc.) and when React tried to
+  // coerce it to a string using `'' + value`, an exception was thrown.
+  //
+  // The most common types that will cause this exception are `Symbol` instances
+  // and Temporal objects like `Temporal.Instant`. But any object that has a
+  // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+  // exception. (Library authors do this to prevent users from using built-in
+  // numeric operators like `+` or comparison operators like `>=` because custom
+  // methods are needed to perform accurate arithmetic or comparison.)
+  //
+  // To fix the problem, coerce this object or symbol value to a string before
+  // passing it to React. The most reliable way is usually `String(value)`.
+  //
+  // To find which value is throwing, check the browser or debugger console.
+  // Before this exception was thrown, there should be `console.error` output
+  // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+  // problem and how that type was used: key, atrribute, input value prop, etc.
+  // In most cases, this console output also shows the component and its
+  // ancestor components where the exception happened.
+  //
+  // eslint-disable-next-line react-internal/safe-string-coercion
+  return '' + value;
+}
+function checkKeyStringCoercion(value) {
+  {
+    if (willCoercionThrow(value)) {
+      error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
+
+      return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+    }
+  }
+}
+
+var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+var RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+var specialPropKeyWarningShown;
+var specialPropRefWarningShown;
+var didWarnAboutStringRefs;
+
+{
+  didWarnAboutStringRefs = {};
+}
+
+function hasValidRef(config) {
+  {
+    if (hasOwnProperty.call(config, 'ref')) {
+      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+
+      if (getter && getter.isReactWarning) {
+        return false;
+      }
+    }
+  }
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+  {
+    if (hasOwnProperty.call(config, 'key')) {
+      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+
+      if (getter && getter.isReactWarning) {
+        return false;
+      }
+    }
+  }
+
+  return config.key !== undefined;
+}
+
+function warnIfStringRefCannotBeAutoConverted(config, self) {
+  {
+    if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
+      var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+
+      if (!didWarnAboutStringRefs[componentName]) {
+        error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
+
+        didWarnAboutStringRefs[componentName] = true;
+      }
+    }
+  }
+}
+
+function defineKeyPropWarningGetter(props, displayName) {
+  {
+    var warnAboutAccessingKey = function () {
+      if (!specialPropKeyWarningShown) {
+        specialPropKeyWarningShown = true;
+
+        error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+      }
+    };
+
+    warnAboutAccessingKey.isReactWarning = true;
+    Object.defineProperty(props, 'key', {
+      get: warnAboutAccessingKey,
+      configurable: true
+    });
+  }
+}
+
+function defineRefPropWarningGetter(props, displayName) {
+  {
+    var warnAboutAccessingRef = function () {
+      if (!specialPropRefWarningShown) {
+        specialPropRefWarningShown = true;
+
+        error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+      }
+    };
+
+    warnAboutAccessingRef.isReactWarning = true;
+    Object.defineProperty(props, 'ref', {
+      get: warnAboutAccessingRef,
+      configurable: true
+    });
+  }
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+var ReactElement = function (type, key, ref, self, source, owner, props) {
+  var element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: ref,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  {
+    // The validation flag is currently mutative. We put it on
+    // an external backing store so that we can freeze the whole object.
+    // This can be replaced with a WeakMap once they are implemented in
+    // commonly used development environments.
+    element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
+    // the validation flag non-enumerable (where possible, which should
+    // include every environment we run tests in), so the test framework
+    // ignores it.
+
+    Object.defineProperty(element._store, 'validated', {
+      configurable: false,
+      enumerable: false,
+      writable: true,
+      value: false
+    }); // self and source are DEV only properties.
+
+    Object.defineProperty(element, '_self', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: self
+    }); // Two elements created in two different places should be considered
+    // equal for testing purposes and therefore we hide it from enumeration.
+
+    Object.defineProperty(element, '_source', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: source
+    });
+
+    if (Object.freeze) {
+      Object.freeze(element.props);
+      Object.freeze(element);
+    }
+  }
+
+  return element;
+};
+/**
+ * https://github.com/reactjs/rfcs/pull/107
+ * @param {*} type
+ * @param {object} props
+ * @param {string} key
+ */
+
+function jsxDEV(type, config, maybeKey, source, self) {
+  {
+    var propName; // Reserved names are extracted
+
+    var props = {};
+    var key = null;
+    var ref = null; // Currently, key can be spread in as a prop. This causes a potential
+    // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
+    // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
+    // but as an intermediary step, we will use jsxDEV for everything except
+    // <div {...props} key="Hi" />, because we aren't currently able to tell if
+    // key is explicitly declared to be undefined or not.
+
+    if (maybeKey !== undefined) {
+      {
+        checkKeyStringCoercion(maybeKey);
+      }
+
+      key = '' + maybeKey;
+    }
+
+    if (hasValidKey(config)) {
+      {
+        checkKeyStringCoercion(config.key);
+      }
+
+      key = '' + config.key;
+    }
+
+    if (hasValidRef(config)) {
+      ref = config.ref;
+      warnIfStringRefCannotBeAutoConverted(config, self);
+    } // Remaining properties are added to a new props object
+
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        props[propName] = config[propName];
+      }
+    } // Resolve default props
+
+
+    if (type && type.defaultProps) {
+      var defaultProps = type.defaultProps;
+
+      for (propName in defaultProps) {
+        if (props[propName] === undefined) {
+          props[propName] = defaultProps[propName];
+        }
+      }
+    }
+
+    if (key || ref) {
+      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+
+      if (key) {
+        defineKeyPropWarningGetter(props, displayName);
+      }
+
+      if (ref) {
+        defineRefPropWarningGetter(props, displayName);
+      }
+    }
+
+    return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+  }
+}
+
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+
+function setCurrentlyValidatingElement$1(element) {
+  {
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+    }
+  }
+}
+
+var propTypesMisspellWarningShown;
+
+{
+  propTypesMisspellWarningShown = false;
+}
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param {?object} object
+ * @return {boolean} True if `object` is a ReactElement.
+ * @final
+ */
+
+
+function isValidElement(object) {
+  {
+    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+  }
+}
+
+function getDeclarationErrorAddendum() {
+  {
+    if (ReactCurrentOwner$1.current) {
+      var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
+
+      if (name) {
+        return '\n\nCheck the render method of `' + name + '`.';
+      }
+    }
+
+    return '';
+  }
+}
+
+function getSourceInfoErrorAddendum(source) {
+  {
+    if (source !== undefined) {
+      var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+      var lineNumber = source.lineNumber;
+      return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
+    }
+
+    return '';
+  }
+}
+/**
+ * Warn if there's no key explicitly set on dynamic arrays of children or
+ * object keys are not valid. This allows us to keep track of children between
+ * updates.
+ */
+
+
+var ownerHasKeyUseWarning = {};
+
+function getCurrentComponentErrorInfo(parentType) {
+  {
+    var info = getDeclarationErrorAddendum();
+
+    if (!info) {
+      var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
+
+      if (parentName) {
+        info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+      }
+    }
+
+    return info;
+  }
+}
+/**
+ * Warn if the element doesn't have an explicit key assigned to it.
+ * This element is in an array. The array could grow and shrink or be
+ * reordered. All children that haven't already been validated are required to
+ * have a "key" property assigned to it. Error statuses are cached so a warning
+ * will only be shown once.
+ *
+ * @internal
+ * @param {ReactElement} element Element that requires a key.
+ * @param {*} parentType element's parent's type.
+ */
+
+
+function validateExplicitKey(element, parentType) {
+  {
+    if (!element._store || element._store.validated || element.key != null) {
+      return;
+    }
+
+    element._store.validated = true;
+    var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+
+    if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+      return;
+    }
+
+    ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+    // property, it may be the creator of the child that's responsible for
+    // assigning it a key.
+
+    var childOwner = '';
+
+    if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
+      // Give the component that originally created this child.
+      childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+    }
+
+    setCurrentlyValidatingElement$1(element);
+
+    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
+
+    setCurrentlyValidatingElement$1(null);
+  }
+}
+/**
+ * Ensure that every element either is passed in a static location, in an
+ * array with an explicit keys property defined, or in an object literal
+ * with valid key property.
+ *
+ * @internal
+ * @param {ReactNode} node Statically passed child of any type.
+ * @param {*} parentType node's parent's type.
+ */
+
+
+function validateChildKeys(node, parentType) {
+  {
+    if (typeof node !== 'object') {
+      return;
+    }
+
+    if (isArray(node)) {
+      for (var i = 0; i < node.length; i++) {
+        var child = node[i];
+
+        if (isValidElement(child)) {
+          validateExplicitKey(child, parentType);
+        }
+      }
+    } else if (isValidElement(node)) {
+      // This element was passed in a valid location.
+      if (node._store) {
+        node._store.validated = true;
+      }
+    } else if (node) {
+      var iteratorFn = getIteratorFn(node);
+
+      if (typeof iteratorFn === 'function') {
+        // Entry iterators used to provide implicit keys,
+        // but now we print a separate warning for them later.
+        if (iteratorFn !== node.entries) {
+          var iterator = iteratorFn.call(node);
+          var step;
+
+          while (!(step = iterator.next()).done) {
+            if (isValidElement(step.value)) {
+              validateExplicitKey(step.value, parentType);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+/**
+ * Given an element, validate that its props follow the propTypes definition,
+ * provided by the type.
+ *
+ * @param {ReactElement} element
+ */
+
+
+function validatePropTypes(element) {
+  {
+    var type = element.type;
+
+    if (type === null || type === undefined || typeof type === 'string') {
+      return;
+    }
+
+    var propTypes;
+
+    if (typeof type === 'function') {
+      propTypes = type.propTypes;
+    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+    // Inner props are checked in the reconciler.
+    type.$$typeof === REACT_MEMO_TYPE)) {
+      propTypes = type.propTypes;
+    } else {
+      return;
+    }
+
+    if (propTypes) {
+      // Intentionally inside to avoid triggering lazy initializers:
+      var name = getComponentNameFromType(type);
+      checkPropTypes(propTypes, element.props, 'prop', name, element);
+    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
+
+      var _name = getComponentNameFromType(type);
+
+      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
+    }
+
+    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
+      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
+    }
+  }
+}
+/**
+ * Given a fragment, validate that it can only be provided with fragment props
+ * @param {ReactElement} fragment
+ */
+
+
+function validateFragmentProps(fragment) {
+  {
+    var keys = Object.keys(fragment.props);
+
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+
+      if (key !== 'children' && key !== 'key') {
+        setCurrentlyValidatingElement$1(fragment);
+
+        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+
+        setCurrentlyValidatingElement$1(null);
+        break;
+      }
+    }
+
+    if (fragment.ref !== null) {
+      setCurrentlyValidatingElement$1(fragment);
+
+      error('Invalid attribute `ref` supplied to `React.Fragment`.');
+
+      setCurrentlyValidatingElement$1(null);
+    }
+  }
+}
+
+function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
+  {
+    var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+    // succeed and there will likely be errors in render.
+
+    if (!validType) {
+      var info = '';
+
+      if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+        info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
+      }
+
+      var sourceInfo = getSourceInfoErrorAddendum(source);
+
+      if (sourceInfo) {
+        info += sourceInfo;
+      } else {
+        info += getDeclarationErrorAddendum();
+      }
+
+      var typeString;
+
+      if (type === null) {
+        typeString = 'null';
+      } else if (isArray(type)) {
+        typeString = 'array';
+      } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+        typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+        info = ' Did you accidentally export a JSX literal instead of a component?';
+      } else {
+        typeString = typeof type;
+      }
+
+      error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+    }
+
+    var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used.
+    // TODO: Drop this when these are no longer allowed as the type argument.
+
+    if (element == null) {
+      return element;
+    } // Skip key warning if the type isn't valid since our key validation logic
+    // doesn't expect a non-string/function type and can throw confusing errors.
+    // We don't want exception behavior to differ between dev and prod.
+    // (Rendering will throw with a helpful message and as soon as the type is
+    // fixed, the key warnings will appear.)
+
+
+    if (validType) {
+      var children = props.children;
+
+      if (children !== undefined) {
+        if (isStaticChildren) {
+          if (isArray(children)) {
+            for (var i = 0; i < children.length; i++) {
+              validateChildKeys(children[i], type);
+            }
+
+            if (Object.freeze) {
+              Object.freeze(children);
+            }
+          } else {
+            error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.');
+          }
+        } else {
+          validateChildKeys(children, type);
+        }
+      }
+    }
+
+    if (type === REACT_FRAGMENT_TYPE) {
+      validateFragmentProps(element);
+    } else {
+      validatePropTypes(element);
+    }
+
+    return element;
+  }
+} // These two functions exist to still get child warnings in dev
+// even with the prod transform. This means that jsxDEV is purely
+// opt-in behavior for better messages but that we won't stop
+// giving you warnings if you use production apis.
+
+function jsxWithValidationStatic(type, props, key) {
+  {
+    return jsxWithValidation(type, props, key, true);
+  }
+}
+function jsxWithValidationDynamic(type, props, key) {
+  {
+    return jsxWithValidation(type, props, key, false);
+  }
+}
+
+var jsx =  jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children.
+// for now we can ship identical prod functions
+
+var jsxs =  jsxWithValidationStatic ;
+
+exports.Fragment = REACT_FRAGMENT_TYPE;
+exports.jsx = jsx;
+exports.jsxs = jsxs;
+  })();
+}
+});
+
+var jsxRuntime = createCommonjsModule(function (module) {
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = reactJsxRuntime_production_min;
+} else {
+  module.exports = reactJsxRuntime_development;
+}
+});
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -500,37 +1867,37 @@ var tslib_es6 = {
 };
 
 var tslib_es6$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  __extends: __extends,
-  get __assign () { return __assign; },
-  __rest: __rest,
-  __decorate: __decorate,
-  __param: __param,
-  __esDecorate: __esDecorate,
-  __runInitializers: __runInitializers,
-  __propKey: __propKey,
-  __setFunctionName: __setFunctionName,
-  __metadata: __metadata,
-  __awaiter: __awaiter,
-  __generator: __generator,
-  __createBinding: __createBinding,
-  __exportStar: __exportStar,
-  __values: __values,
-  __read: __read,
-  __spread: __spread,
-  __spreadArrays: __spreadArrays,
-  __spreadArray: __spreadArray,
-  __await: __await,
-  __asyncGenerator: __asyncGenerator,
-  __asyncDelegator: __asyncDelegator,
-  __asyncValues: __asyncValues,
-  __makeTemplateObject: __makeTemplateObject,
-  __importStar: __importStar,
-  __importDefault: __importDefault,
-  __classPrivateFieldGet: __classPrivateFieldGet,
-  __classPrivateFieldSet: __classPrivateFieldSet,
-  __classPrivateFieldIn: __classPrivateFieldIn,
-  'default': tslib_es6
+	__proto__: null,
+	__extends: __extends,
+	get __assign () { return __assign; },
+	__rest: __rest,
+	__decorate: __decorate,
+	__param: __param,
+	__esDecorate: __esDecorate,
+	__runInitializers: __runInitializers,
+	__propKey: __propKey,
+	__setFunctionName: __setFunctionName,
+	__metadata: __metadata,
+	__awaiter: __awaiter,
+	__generator: __generator,
+	__createBinding: __createBinding,
+	__exportStar: __exportStar,
+	__values: __values,
+	__read: __read,
+	__spread: __spread,
+	__spreadArrays: __spreadArrays,
+	__spreadArray: __spreadArray,
+	__await: __await,
+	__asyncGenerator: __asyncGenerator,
+	__asyncDelegator: __asyncDelegator,
+	__asyncValues: __asyncValues,
+	__makeTemplateObject: __makeTemplateObject,
+	__importStar: __importStar,
+	__importDefault: __importDefault,
+	__classPrivateFieldGet: __classPrivateFieldGet,
+	__classPrivateFieldSet: __classPrivateFieldSet,
+	__classPrivateFieldIn: __classPrivateFieldIn,
+	'default': tslib_es6
 });
 
 let currentId$1 = 0;
@@ -8779,30 +10146,6 @@ ExpandableSection.defaultProps = {
     variant: 'default'
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-function getAugmentedNamespace(n) {
-	if (n.__esModule) return n;
-	var a = Object.defineProperty({}, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
-}
-
 var labelStyles = {
   "button": "pf-v6-c-button",
   "label": "pf-v6-c-label",
@@ -11104,27 +12447,27 @@ const useValuesForQuickStartContext = (value = {}) => {
     var _a, _b;
     const combinedValue = Object.assign(Object.assign({}, QuickStartContextDefaults), value);
     const { activeQuickStartID, setActiveQuickStartID, setAllQuickStartStates, useQueryParams, allQuickStartStates, allQuickStarts = [], footer, useLegacyHeaderColors, markdown, } = combinedValue;
-    const [quickStarts, setQuickStarts] = React__default.useState(combinedValue.allQuickStarts || []);
-    const [resourceBundle, setResourceBundle] = React__default.useState(Object.assign(Object.assign({}, en), combinedValue.resourceBundle));
-    const [language, setLanguage] = React__default.useState(combinedValue.language);
+    const [quickStarts, setQuickStarts] = useState(combinedValue.allQuickStarts || []);
+    const [resourceBundle, setResourceBundle] = useState(Object.assign(Object.assign({}, en), combinedValue.resourceBundle));
+    const [language, setLanguage] = useState(combinedValue.language);
     const changeResourceBundle = (bundle, lng) => {
         lng && setLanguage(lng);
         setResourceBundle(Object.assign(Object.assign({}, en), bundle));
     };
     const findResource = useCallback((resource, count) => getResource(resource, count !== undefined ? { count } : null, resourceBundle, language), [resourceBundle, language]);
-    const [loading, setLoading] = React__default.useState(combinedValue.loading);
-    const [alwaysShowTaskReview, setAlwaysShowTaskReview] = React__default.useState(combinedValue.alwaysShowTaskReview);
+    const [loading, setLoading] = useState(combinedValue.loading);
+    const [alwaysShowTaskReview, setAlwaysShowTaskReview] = useState(combinedValue.alwaysShowTaskReview);
     const initialSearchParams = new URLSearchParams(window.location.search);
     const initialSearchQuery = initialSearchParams.get(QUICKSTART_SEARCH_FILTER_KEY) || '';
     const initialStatusFilters = ((_a = initialSearchParams.get(QUICKSTART_STATUS_FILTER_KEY)) === null || _a === void 0 ? void 0 : _a.split(',')) || [];
     const quickStartStatusCount = getQuickStartStatusCount(allQuickStartStates, allQuickStarts);
-    const [statusTypes, setStatusTypes] = React__default.useState({
+    const [statusTypes, setStatusTypes] = useState({
         [QuickStartStatus.COMPLETE]: findResource('Complete ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[QuickStartStatus.COMPLETE]),
         [QuickStartStatus.IN_PROGRESS]: findResource('In progress ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[QuickStartStatus.IN_PROGRESS]),
         [QuickStartStatus.NOT_STARTED]: findResource('Not started ({{statusCount, number}})').replace('{{statusCount, number}}', quickStartStatusCount[QuickStartStatus.NOT_STARTED]),
     });
-    const [statusFilters, setStatusFilters] = React__default.useState(initialStatusFilters);
-    const [filterKeyword, setFilterKeyword] = React__default.useState(initialSearchQuery);
+    const [statusFilters, setStatusFilters] = useState(initialStatusFilters);
+    const [filterKeyword, setFilterKeyword] = useState(initialSearchQuery);
     const setFilter = (type, val) => {
         if (type === 'keyword') {
             setFilterKeyword(val);
@@ -11133,7 +12476,7 @@ const useValuesForQuickStartContext = (value = {}) => {
             setStatusFilters(val);
         }
     };
-    React__default.useEffect(() => {
+    useEffect(() => {
         const updatedQuickStartStatusCount = getQuickStartStatusCount(allQuickStartStates, quickStarts);
         setStatusTypes({
             [QuickStartStatus.COMPLETE]: findResource('Complete ({{statusCount, number}})').replace('{{statusCount, number}}', updatedQuickStartStatusCount[QuickStartStatus.COMPLETE]),
@@ -11305,24 +12648,18 @@ const useValuesForQuickStartContext = (value = {}) => {
         setAlwaysShowTaskReview,
     };
 };
-const QuickStartContextProvider = ({ children, value }) => (React__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.createElement("div", { className: css('pfext-status-box', className) }, children));
-const Loading = ({ className }) => (React.createElement("div", { className: css('pfext-m-loader', className) },
-    React.createElement("div", { className: "pfext-m-loader-dot__one" }),
-    React.createElement("div", { className: "pfext-m-loader-dot__two" }),
-    React.createElement("div", { className: "pfext-m-loader-dot__three" })));
+const Box = ({ children, className }) => (jsxRuntime.jsx("div", Object.assign({ className: css('pfext-status-box', className) }, { children: children })));
+const Loading = ({ className }) => (jsxRuntime.jsxs("div", Object.assign({ className: 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.createElement(Box, { className: css('pfext-status-box--loading', className) },
-    React.createElement(Loading, null),
-    message && React.createElement("div", { className: "pfext-status-box__loading-message" }, message)));
+const LoadingBox = ({ className, message }) => (jsxRuntime.jsxs(Box, Object.assign({ className: 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.useContext(QuickStartContext);
-    return (React.createElement(Box, null,
-        React.createElement("div", { "data-test": "empty-message", className: "text-center" }, label
-            ? getResource('No {{label}} found').replace('{{label}}', label)
-            : getResource('Not found'))));
+    const { getResource } = useContext(QuickStartContext);
+    return (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';
 
@@ -11336,9 +12673,7 @@ const CamelCaseWrap = ({ value, dataTest }) => {
     }
     // Add word break points before capital letters (but keep consecutive capital letters together).
     const words = value.match(/[A-Z]+[^A-Z]*|[^A-Z]+/g);
-    const rendered = (React.createElement("span", { "data-test": dataTest }, words.map((word, i) => (React.createElement(React.Fragment, { key: i },
-        word,
-        i !== words.length - 1 && React.createElement("wbr", null))))));
+    const rendered = (jsxRuntime.jsx("span", Object.assign({ "data-test": dataTest }, { children: words.map((word, i) => (jsxRuntime.jsxs(Fragment$1, { children: [word, i !== words.length - 1 && jsxRuntime.jsx("wbr", {})] }, i))) })));
     MEMO[value] = rendered;
     return rendered;
 };
@@ -11361,40 +12696,40 @@ var RocketIcon = /*@__PURE__*/getDefaultExportFromCjs(rocketIcon);
 
 const Modal = (_a) => {
     var { isFullScreen = false, className } = _a, props = __rest(_a, ["isFullScreen", "className"]);
-    return (React.createElement(Modal$1, Object.assign({}, props, { className: css('pfext-modal', className), appendTo: () => (isFullScreen ? document.body : document.querySelector('#modal-container')) })));
+    return (jsxRuntime.jsx(Modal$1, Object.assign({}, props, { className: css('pfext-modal', className), appendTo: () => (isFullScreen ? document.body : document.querySelector('#modal-container')) })));
 };
 
 const getContainer = (container) => typeof container === 'function' ? container() : container;
 const Portal = ({ children, container }) => {
-    const [containerNode, setContainerNode] = React.useState();
+    const [containerNode, setContainerNode] = useState();
     useIsomorphicLayoutEffect(() => {
         setContainerNode(getContainer(container) || document.body);
     }, [container]);
-    return containerNode ? ReactDOM.createPortal(children, containerNode) : null;
+    return containerNode ? createPortal(children, containerNode) : null;
 };
 
 const SimplePopper = ({ children }) => {
     const openProp = true;
-    const nodeRef = React.useRef();
-    const popperRef = React.useRef(null);
-    const [isOpen, setOpenState] = React.useState(openProp);
-    const setOpen = React.useCallback((newOpen) => {
+    const nodeRef = useRef(null);
+    const popperRef = useRef(null);
+    const [isOpen, setOpenState] = useState(openProp);
+    const setOpen = useCallback((newOpen) => {
         setOpenState(newOpen);
     }, []);
-    React.useEffect(() => {
+    useEffect(() => {
         setOpen(openProp);
     }, [openProp, setOpen]);
-    const onKeyDown = React.useCallback((e) => {
+    const onKeyDown = useCallback((e) => {
         if (e.keyCode === 27) {
             setOpen(false);
         }
     }, [setOpen]);
-    const onClickOutside = React.useCallback((e) => {
+    const onClickOutside = useCallback((e) => {
         if (!nodeRef.current || (e.target instanceof Node && !nodeRef.current.contains(e.target))) {
             setOpen(false);
         }
     }, [setOpen]);
-    const destroy = React.useCallback(() => {
+    const destroy = useCallback(() => {
         if (popperRef.current) {
             popperRef.current.destroy();
             document.removeEventListener('keydown', onKeyDown, true);
@@ -11402,29 +12737,28 @@ const SimplePopper = ({ children }) => {
             document.removeEventListener('touchstart', onClickOutside, true);
         }
     }, [onClickOutside, onKeyDown]);
-    const initialize = React.useCallback(() => {
+    const initialize = useCallback(() => {
         if (!nodeRef.current || !isOpen) {
             return;
         }
         destroy();
     }, [isOpen, destroy]);
-    const nodeRefCallback = React.useCallback((node) => {
+    const nodeRefCallback = useCallback((node) => {
         nodeRef.current = node;
         initialize();
     }, [initialize]);
-    React.useEffect(() => {
+    useEffect(() => {
         initialize();
     }, [initialize]);
-    React.useEffect(() => () => {
+    useEffect(() => () => {
         destroy();
     }, [destroy]);
-    React.useEffect(() => {
+    useEffect(() => {
         if (!isOpen) {
             destroy();
         }
     }, [destroy, isOpen]);
-    return isOpen ? (React.createElement(Portal, null,
-        React.createElement("div", { ref: nodeRefCallback, style: { zIndex: 9999, position: 'absolute', top: 0, left: 0 }, className: "pfext-quick-start__base" }, children))) : null;
+    return isOpen ? (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) => {
@@ -11444,8 +12778,8 @@ const InteractiveSpotlight = ({ element }) => {
         bottom,
         right,
     };
-    const [clicked, setClicked] = React.useState(false);
-    React.useEffect(() => {
+    const [clicked, setClicked] = useState(false);
+    useEffect(() => {
         if (!clicked) {
             if (!isInViewport(element)) {
                 element.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
@@ -11461,9 +12795,7 @@ const InteractiveSpotlight = ({ element }) => {
     if (clicked) {
         return null;
     }
-    return (React.createElement(Portal, null,
-        React.createElement(SimplePopper, null,
-            React.createElement("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-animate", style: style }))));
+    return (jsxRuntime.jsx(Portal, { children: jsxRuntime.jsx(SimplePopper, { children: jsxRuntime.jsx("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-animate", style: style }) }) }));
 };
 
 var ScrollDirection;
@@ -11475,8 +12807,8 @@ var ScrollDirection;
 })(ScrollDirection || (ScrollDirection = {}));
 
 const useResizeObserver = (callback, targetElement, observerOptions = undefined) => {
-    const element = React.useMemo(() => targetElement !== null && targetElement !== void 0 ? targetElement : document.querySelector('body'), [targetElement]);
-    React.useEffect(() => {
+    const element = useMemo(() => targetElement !== null && targetElement !== void 0 ? targetElement : document.querySelector('body'), [targetElement]);
+    useEffect(() => {
         const observer = new ResizeObserver(callback);
         observer.observe(element, observerOptions);
         return () => {
@@ -11494,8 +12826,8 @@ var Shadows;
 })(Shadows || (Shadows = {}));
 
 const useBoundingClientRect = (targetElement) => {
-    const [clientRect, setClientRect] = React.useState(() => targetElement ? targetElement.getBoundingClientRect() : null);
-    const observerCallback = React.useCallback(() => {
+    const [clientRect, setClientRect] = useState(() => targetElement ? targetElement.getBoundingClientRect() : null);
+    const observerCallback = useCallback(() => {
         setClientRect(targetElement ? targetElement.getBoundingClientRect() : null);
     }, [targetElement]);
     useResizeObserver(observerCallback);
@@ -11505,7 +12837,7 @@ const useBoundingClientRect = (targetElement) => {
 /**
  * React hook that forces component render.
  */
-const useForceRender = () => React.useReducer((s) => !s, false)[1];
+const useForceRender = () => useReducer((s) => !s, false)[1];
 
 const useEventListener = (target, event, callback) => {
     useEffect(() => {
@@ -11526,14 +12858,12 @@ const StaticSpotlight = ({ element }) => {
             width: clientRect.width,
         }
         : {};
-    return clientRect ? (React.createElement(Portal, null,
-        React.createElement("div", { className: "pf-v6-c-backdrop pfext-spotlight__with-backdrop" },
-            React.createElement("div", { className: "pfext-spotlight pfext-spotlight__element-highlight-noanimate", style: style })))) : null;
+    return clientRect ? (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.useMemo(() => {
+    const element = useMemo(() => {
         const highlightElement = document.querySelector(selector);
         let hiddenElement = highlightElement;
         while (hiddenElement) {
@@ -11548,12 +12878,12 @@ const Spotlight = ({ selector, interactive }) => {
     if (!element) {
         return null;
     }
-    return interactive ? (React.createElement(InteractiveSpotlight, { element: element })) : (React.createElement(StaticSpotlight, { element: element }));
+    return interactive ? (jsxRuntime.jsx(InteractiveSpotlight, { element: element })) : (jsxRuntime.jsx(StaticSpotlight, { element: element }));
 };
 
 const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
-    const [selector, setSelector] = React.useState(null);
-    React.useEffect(() => {
+    const [selector, setSelector] = useState(null);
+    useEffect(() => {
         const elements = docContext.querySelectorAll(`${rootSelector} [data-highlight]`);
         let timeoutId;
         function startHighlight(e) {
@@ -11572,7 +12902,7 @@ const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
             elements && elements.forEach((elm) => elm.removeEventListener('click', startHighlight));
         };
     }, [docContext, rootSelector]);
-    React.useEffect(() => {
+    useEffect(() => {
         const elements = docContext.querySelectorAll(`${rootSelector} [class^=data-highlight__]`);
         let timeoutId;
         function startHighlight(e) {
@@ -11602,7 +12932,7 @@ const MarkdownHighlightExtension = ({ docContext, rootSelector, }) => {
     if (!selector) {
         return null;
     }
-    return React.createElement(Spotlight, { selector: selector, interactive: true });
+    return jsxRuntime.jsx(Spotlight, { selector: selector, interactive: true });
 };
 
 const MARKDOWN_COPY_BUTTON_ID = 'data-copy-for';
@@ -11610,15 +12940,15 @@ const MARKDOWN_SNIPPET_ID = 'data-snippet-id';
 const ACCORDION_MARKDOWN_BUTTON_ID = `accordion-markdown-button-id`;
 const ACCORDION_MARKDOWN_CONTENT_ID = `accordion-markdown-content-id`;
 
-const CopyClipboard = ({ element, rootSelector, docContext, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    const [showSuccessContent, setShowSuccessContent] = React.useState(false);
-    const textToCopy = React.useMemo(() => {
+const CopyClipboard = ({ element, rootSelector, docContext }) => {
+    const { getResource } = useContext(QuickStartContext);
+    const [showSuccessContent, setShowSuccessContent] = useState(false);
+    const textToCopy = useMemo(() => {
         var _a;
         const copyTextId = element.getAttribute(MARKDOWN_COPY_BUTTON_ID);
         return (_a = docContext.querySelector(`${rootSelector} [${MARKDOWN_SNIPPET_ID}="${copyTextId}"]`)) === null || _a === void 0 ? void 0 : _a.innerText;
     }, [element, docContext, rootSelector]);
-    useEventListener(element, 'click', React.useCallback(() => {
+    useEventListener(element, 'click', useCallback(() => {
         navigator.clipboard
             .writeText(textToCopy.trim())
             .then(() => {
@@ -11626,17 +12956,17 @@ const CopyClipboard = ({ element, rootSelector, docContext, }) => {
         })
             .catch(() => { });
     }, [textToCopy]));
-    useEventListener(element, 'mouseleave', React.useCallback(() => {
+    useEventListener(element, 'mouseleave', useCallback(() => {
         setShowSuccessContent(false);
     }, []));
-    return showSuccessContent ? (React.createElement(Tooltip, { key: "after-copy", isVisible: true, triggerRef: () => element, content: getResource('Successfully copied to clipboard!'), className: "pfext-quick-start__base" })) : (React.createElement(Tooltip, { key: "before-copy", triggerRef: () => element, content: getResource('Copy to clipboard'), className: "pfext-quick-start__base" }));
+    return showSuccessContent ? (jsxRuntime.jsx(Tooltip, { isVisible: true, triggerRef: () => element, content: getResource('Successfully copied to clipboard!'), className: "pfext-quick-start__base" }, "after-copy")) : (jsxRuntime.jsx(Tooltip, { triggerRef: () => element, content: getResource('Copy to clipboard'), className: "pfext-quick-start__base" }, "before-copy"));
 };
-const MarkdownCopyClipboard = ({ docContext, rootSelector, }) => {
+const MarkdownCopyClipboard = ({ docContext, rootSelector }) => {
     const elements = docContext.querySelectorAll(`${rootSelector} [${MARKDOWN_COPY_BUTTON_ID}]`);
-    return elements.length > 0 ? (React.createElement(React.Fragment, null, Array.from(elements).map((elm) => {
-        const attributeValue = elm.getAttribute(MARKDOWN_COPY_BUTTON_ID);
-        return (React.createElement(CopyClipboard, { key: attributeValue, element: elm, rootSelector: rootSelector, docContext: docContext }));
-    }))) : null;
+    return elements.length > 0 ? (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, '><');
@@ -26031,8 +27361,8 @@ exports["default"] = exports.CopyIcon;
 var CopyIcon = /*@__PURE__*/getDefaultExportFromCjs(copyIcon);
 
 const useInlineCopyClipboardShowdownExtension = () => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return React.useMemo(() => ({
+    const { getResource } = useContext(QuickStartContext);
+    return useMemo(() => ({
         type: 'lang',
         regex: /`([^`](.*?)[^`])`{{copy}}/g,
         replace: (text, group, _, groupId) => {
@@ -26044,7 +27374,7 @@ const useInlineCopyClipboardShowdownExtension = () => {
               <span class="pf-v6-c-clipboard-copy__actions">
                 <span class="pf-v6-c-clipboard-copy__actions-item">
                   <button class="pf-v6-c-button pf-m-plain" aria-label="${getResource('Copy to clipboard')}" ${MARKDOWN_COPY_BUTTON_ID}="${groupId}">
-                    ${renderToStaticMarkup(React.createElement(CopyIcon, null))}
+                    ${renderToStaticMarkup(jsxRuntime.jsx(CopyIcon, {}))}
                   </button>
                 </span>
               </span>
@@ -26053,10 +27383,9 @@ const useInlineCopyClipboardShowdownExtension = () => {
     }), [getResource]);
 };
 
-/* eslint-disable max-len */
 const useMultilineCopyClipboardShowdownExtension = () => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return React.useMemo(() => ({
+    const { getResource } = useContext(QuickStartContext);
+    return useMemo(() => ({
         type: 'lang',
         regex: /```[\n]\s*((((?!```).)*?\n)+)\s*```{{copy}}/g,
         replace: (text, group, _1, _2, groupId) => {
@@ -26068,7 +27397,7 @@ const useMultilineCopyClipboardShowdownExtension = () => {
                 <div class="pf-v6-c-code-block__actions">
                   <div class="pf-v6-c-code-block__actions-item">
                     <button class="pf-v6-c-button pf-m-plain" type="button" aria-label="${getResource('Copy to clipboard')}" ${MARKDOWN_COPY_BUTTON_ID}="${groupId}">
-                      ${renderToStaticMarkup(React.createElement(CopyIcon, null))}
+                      ${renderToStaticMarkup(jsxRuntime.jsx(CopyIcon, {}))}
                     </button>
                   </div>
                 </div>
@@ -28757,9 +30086,9 @@ const markdownConvert = (markdown, extensions) => __awaiter(void 0, void 0, void
     return DOMPurify.sanitize(md);
 });
 const SyncMarkdownView = ({ content, emptyMsg, extensions, renderExtension, exactHeight, inline, className, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    const [markup, setMarkup] = React.useState('');
-    React.useEffect(() => {
+    const { getResource } = useContext(QuickStartContext);
+    const [markup, setMarkup] = useState('');
+    useEffect(() => {
         function getMd() {
             return __awaiter(this, void 0, void 0, function* () {
                 const md = yield markdownConvert(content || emptyMsg || getResource('Not available'), extensions);
@@ -28775,7 +30104,7 @@ const SyncMarkdownView = ({ content, emptyMsg, extensions, renderExtension, exac
         isEmpty: !content,
         className,
     };
-    return inline ? React.createElement(InlineMarkdownView, Object.assign({}, innerProps)) : React.createElement(IFrameMarkdownView, Object.assign({}, innerProps));
+    return inline ? jsxRuntime.jsx(InlineMarkdownView, Object.assign({}, innerProps)) : jsxRuntime.jsx(IFrameMarkdownView, Object.assign({}, innerProps));
 };
 const uniqueId = (function () {
     let num = 0;
@@ -28787,8 +30116,8 @@ const uniqueId = (function () {
 })();
 const RenderExtension = ({ renderExtension, selector, markup, docContext, }) => {
     const forceRender = useForceRender();
-    const markupRef = React.useRef(null);
-    const shouldRenderExtension = React.useCallback(() => {
+    const markupRef = useRef(null);
+    const shouldRenderExtension = useCallback(() => {
         if (markupRef.current === markup) {
             return true;
         }
@@ -28801,25 +30130,23 @@ const RenderExtension = ({ renderExtension, selector, markup, docContext, }) =>
      * which causes the component rendered by renderExtension to receive old copy of document
      * use forceRender to delay the rendering of extension by one render cycle
      */
-    React.useEffect(() => {
+    useEffect(() => {
         if (renderExtension) {
             forceRender();
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [markup]);
-    return (React.createElement(React.Fragment, null, shouldRenderExtension() ? renderExtension === null || renderExtension === void 0 ? void 0 : renderExtension(docContext !== null && docContext !== void 0 ? docContext : document, selector) : null));
+    return (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.useMemo(() => uniqueId('markdown'), []);
-    return (React.createElement("div", { className: css({ 'is-empty': isEmpty }, className), id: id },
-        React.createElement("div", { dangerouslySetInnerHTML: { __html: markup } }),
-        renderExtension && (React.createElement(RenderExtension, { renderExtension: renderExtension, selector: `#${id}`, markup: markup }))));
+    const id = useMemo(() => uniqueId('markdown'), []);
+    return (jsxRuntime.jsxs("div", Object.assign({ className: css({ 'is-empty': isEmpty }, className), id: id }, { children: [jsxRuntime.jsx("div", { dangerouslySetInnerHTML: { __html: markup } }), renderExtension && (jsxRuntime.jsx(RenderExtension, { renderExtension: renderExtension, selector: `#${id}`, markup: markup }))] })));
 };
 const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, className, }) => {
-    const [frame, setFrame] = React.useState();
-    const [loaded, setLoaded] = React.useState(false);
-    const updateTimeoutHandle = React.useRef();
-    const updateDimensions = React.useCallback(() => {
+    const [frame, setFrame] = useState();
+    const [loaded, setLoaded] = useState(false);
+    const updateTimeoutHandle = useRef(null);
+    const updateDimensions = useCallback(() => {
         var _a;
         if (!((_a = frame === null || frame === void 0 ? void 0 : frame.contentWindow) === null || _a === void 0 ? void 0 : _a.document.body.firstChild)) {
             return;
@@ -28836,10 +30163,10 @@ const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, cla
             }
         });
     }, [frame, exactHeight]);
-    React.useEffect(() => () => {
+    useEffect(() => () => {
         clearTimeout(updateTimeoutHandle.current);
     }, []);
-    const onLoad = React.useCallback(() => {
+    const onLoad = useCallback(() => {
         updateDimensions();
         setLoaded(true);
     }, [updateDimensions]);
@@ -28872,9 +30199,9 @@ const IFrameMarkdownView = ({ exactHeight, markup, isEmpty, renderExtension, cla
   }
   </style>
   <body class="pf-m-redhat-font"><div style="overflow-y: auto;">${markup}</div></body>`;
-    return (React.createElement(React.Fragment, null,
-        React.createElement("iframe", { sandbox: "allow-popups allow-popups-to-escape-sandbox allow-same-origin", srcDoc: contents, style: { border: '0px', display: 'block', width: '100%', height: '0' }, ref: (r) => setFrame(r), onLoad: () => onLoad(), className: className }),
-        loaded && frame && renderExtension && (React.createElement(RenderExtension, { markup: markup, selector: '', renderExtension: renderExtension, docContext: frame.contentDocument }))));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("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 && (jsxRuntime.jsx(RenderExtension, { markup: markup, selector: '', renderExtension: renderExtension, docContext: frame.contentDocument }))] }));
 };
 
 const LINK_LABEL = '[\\d\\w\\s-()$!]+';
@@ -28884,13 +30211,13 @@ const SELECTOR_ID = `[\\w-]+`;
 const HIGHLIGHT_REGEXP = new RegExp(`\\[(${LINK_LABEL})]{{(${HIGHLIGHT_ACTIONS.join('|')}) (${SELECTOR_ID})}}`, 'g');
 
 const QuickStartMarkdownView = ({ content, exactHeight, className, }) => {
-    const { markdown } = React.useContext(QuickStartContext);
+    const { markdown } = useContext(QuickStartContext);
     const inlineCopyClipboardShowdownExtension = useInlineCopyClipboardShowdownExtension();
     const multilineCopyClipboardShowdownExtension = useMultilineCopyClipboardShowdownExtension();
     const admonitionShowdownExtension = useAdmonitionShowdownExtension();
     const codeShowdownExtension = useCodeShowdownExtension();
     const accordionShowdownExtension = useAccordionShowdownExtension();
-    return (React.createElement(SyncMarkdownView, { inline: true, content: content, exactHeight: exactHeight, extensions: [
+    return (jsxRuntime.jsx(SyncMarkdownView, { inline: true, content: content, exactHeight: exactHeight, extensions: [
             {
                 type: 'lang',
                 regex: HIGHLIGHT_REGEXP,
@@ -28915,13 +30242,9 @@ const QuickStartMarkdownView = ({ content, exactHeight, className, }) => {
             codeShowdownExtension,
             accordionShowdownExtension,
             ...(markdown ? markdown.extensions : []),
-        ], renderExtension: (docContext, rootSelector) => (React.createElement(React.Fragment, null,
-            React.createElement(AccordionRenderExtension, { docContext: docContext }),
-            React.createElement(MarkdownHighlightExtension, { docContext: docContext, rootSelector: rootSelector }),
-            React.createElement(MarkdownCopyClipboard, { docContext: docContext, rootSelector: rootSelector }),
-            markdown &&
-                markdown.renderExtension &&
-                markdown.renderExtension(docContext, rootSelector))), className: className }));
+        ], 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;
@@ -28934,14 +30257,14 @@ var AdmonitionType;
 })(AdmonitionType || (AdmonitionType = {}));
 const admonitionToAlertVariantMap = {
     [AdmonitionType.NOTE]: { variant: 'info' },
-    [AdmonitionType.TIP]: { variant: 'custom', customIcon: React.createElement(LightbulbIcon, null) },
+    [AdmonitionType.TIP]: { variant: 'custom', customIcon: jsxRuntime.jsx(LightbulbIcon, {}) },
     [AdmonitionType.IMPORTANT]: { variant: 'danger' },
-    [AdmonitionType.CAUTION]: { variant: 'warning', customIcon: React.createElement(FireIcon, null) },
+    [AdmonitionType.CAUTION]: { variant: 'warning', customIcon: jsxRuntime.jsx(FireIcon, {}) },
     [AdmonitionType.WARNING]: { variant: 'warning' },
 };
 const useAdmonitionShowdownExtension = () => 
 // const { getResource } = React.useContext<QuickStartContextValues>(QuickStartContext);
-React.useMemo(() => ({
+useMemo(() => ({
     type: 'lang',
     regex: /\[(.+)]{{(admonition) ([\w-]+)}}/g,
     replace: (text, content, admonitionLabel, admonitionType, groupId) => {
@@ -28950,39 +30273,35 @@ React.useMemo(() => ({
         }
         admonitionType = admonitionType.toUpperCase();
         const { variant, customIcon } = admonitionToAlertVariantMap[admonitionType];
-        const mdContent = React.createElement(QuickStartMarkdownView, { content: content });
-        const pfAlert = (React.createElement(Alert, Object.assign({ variant: variant }, (customIcon && { customIcon }), { isInline: true, title: admonitionType, className: "pfext-markdown-admonition" }), mdContent));
+        const mdContent = jsxRuntime.jsx(QuickStartMarkdownView, { content: content });
+        const pfAlert = (jsxRuntime.jsx(Alert, Object.assign({ variant: variant }, (customIcon && { customIcon }), { isInline: true, title: admonitionType, className: "pfext-markdown-admonition" }, { children: mdContent })));
         return removeTemplateWhitespace(renderToStaticMarkup(pfAlert));
     },
 }), []);
 
-const useCodeShowdownExtension = () => React.useMemo(() => ({
+const useCodeShowdownExtension = () => useMemo(() => ({
     type: 'output',
     regex: /<pre><code>(.*?)\n?<\/code><\/pre>/g,
     replace: (text, content) => {
         if (!content) {
             return text;
         }
-        const pfCodeBlock = React.createElement(CodeBlock, null, content);
+        const pfCodeBlock = jsxRuntime.jsx(CodeBlock, { children: content });
         return removeTemplateWhitespace(renderToStaticMarkup(pfCodeBlock));
     },
 }), []);
 
-const useAccordionShowdownExtension = () => React.useMemo(() => ({
+const useAccordionShowdownExtension = () => useMemo(() => ({
     type: 'lang',
     regex: /\[(.+)]{{(accordion) ("(.*?)")}}/g,
     replace: (_text, accordionContent, _command, accordionHeading) => {
         const accordionId = String(accordionHeading).replace(/\s/g, '-');
-        return removeTemplateWhitespace(renderToStaticMarkup(React.createElement(React.Fragment, null,
-            React.createElement(Accordion, { asDefinitionList: true },
-                React.createElement(AccordionItem, { isExpanded: false },
-                    React.createElement(AccordionToggle, { id: `${ACCORDION_MARKDOWN_BUTTON_ID}-${accordionId}` }, accordionHeading),
-                    React.createElement(AccordionContent, { id: `${ACCORDION_MARKDOWN_CONTENT_ID}-${accordionId}` }, accordionContent))))));
+        return removeTemplateWhitespace(renderToStaticMarkup(jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxRuntime.jsx(Accordion, Object.assign({ asDefinitionList: true }, { children: jsxRuntime.jsxs(AccordionItem, Object.assign({ isExpanded: false }, { children: [jsxRuntime.jsx(AccordionToggle, Object.assign({ id: `${ACCORDION_MARKDOWN_BUTTON_ID}-${accordionId}` }, { children: accordionHeading })), jsxRuntime.jsx(AccordionContent, Object.assign({ id: `${ACCORDION_MARKDOWN_CONTENT_ID}-${accordionId}` }, { children: accordionContent }))] })) })) })));
     },
 }), []);
 
 const AccordionShowdownHandler = ({ buttonElement, contentElement, }) => {
-    const [expanded, setExpanded] = React.useState(false);
+    const [expanded, setExpanded] = useState(false);
     const handleClick = () => {
         const expandedModifier = 'pf-m-expanded';
         buttonElement.className = `pf-v6-c-accordion__toggle ${!expanded ? expandedModifier : ''}`;
@@ -28991,27 +30310,27 @@ const AccordionShowdownHandler = ({ buttonElement, contentElement, }) => {
         setExpanded(!expanded);
     };
     useEventListener(buttonElement, 'click', handleClick);
-    return React.createElement(React.Fragment, null);
+    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 ? (React.createElement(React.Fragment, null, Array.from(buttonElements).map((elm) => {
-        const content = Array.from(contentElements).find((elm2) => {
-            const elmId = elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1];
-            const elm2Id = elm2.id.split(ACCORDION_MARKDOWN_CONTENT_ID)[1];
-            return elmId === elm2Id;
-        });
-        return (React.createElement(AccordionShowdownHandler, { key: elm.id.split(ACCORDION_MARKDOWN_BUTTON_ID)[1], buttonElement: elm, contentElement: content }));
-    }))) : null;
+    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);
+    const [isSrcValid, setIsSrcValid] = useState(true);
     if (src && isSrcValid) {
-        return React.createElement("img", { className: className, src: src, alt: alt, onError: () => setIsSrcValid(false) });
+        return jsxRuntime.jsx("img", { className: className, src: src, alt: alt, onError: () => setIsSrcValid(false) });
     }
-    return React.createElement(React.Fragment, null, fallback);
+    return jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
 };
 
 var syncAltIcon = createCommonjsModule(function (module, exports) {
@@ -29032,26 +30351,23 @@ var SyncAltIcon = /*@__PURE__*/getDefaultExportFromCjs(syncAltIcon);
 
 const DASH = '-';
 
-const PopoverStatus = ({ hideHeader, children, isVisible = null, statusBody, title, onHide, onShow, }) => (React.createElement(Popover, { position: PopoverPosition.right, headerContent: hideHeader ? null : title, bodyContent: children, "aria-label": title, onHide: onHide, onShow: onShow, isVisible: isVisible },
-    React.createElement(Button, { variant: "link", isInline: true }, statusBody)));
+const PopoverStatus = ({ hideHeader, children, isVisible = null, statusBody, title, onHide, onShow, }) => (jsxRuntime.jsx(Popover, Object.assign({ position: PopoverPosition.right, headerContent: hideHeader ? null : title, bodyContent: children, "aria-label": title, onHide: onHide, onShow: onShow, isVisible: isVisible }, { children: jsxRuntime.jsx(Button, Object.assign({ variant: "link", isInline: true }, { children: statusBody })) })));
 
 const StatusIconAndText = ({ icon, title, spin, iconOnly, noTooltip, className, }) => {
     if (!title) {
-        return React.createElement(React.Fragment, null, DASH);
+        return jsxRuntime.jsx(jsxRuntime.Fragment, { children: DASH });
     }
-    return (React.createElement("span", { className: css('pfext-icon-and-text', className), title: iconOnly && !noTooltip ? title : undefined },
-        icon &&
-            React.cloneElement(icon, {
-                className: css(spin && 'fa-spin', icon.props.className, !iconOnly && 'pfext-icon-and-text__icon pfext-icon-flex-child'),
-            }),
-        !iconOnly && React.createElement(CamelCaseWrap, { value: title, dataTest: "status-text" })));
+    return (jsxRuntime.jsxs("span", Object.assign({ className: css('pfext-icon-and-text', className), title: iconOnly && !noTooltip ? title : undefined }, { children: [icon &&
+                cloneElement(icon, {
+                    className: css(spin && 'fa-spin', icon.props.className, !iconOnly && 'pfext-icon-and-text__icon pfext-icon-flex-child'),
+                }), !iconOnly && jsxRuntime.jsx(CamelCaseWrap, { value: title, dataTest: "status-text" })] })));
 };
 
 const GenericStatus = (props) => {
     const { Icon, children, popoverTitle, title, noTooltip, iconOnly } = props, restProps = __rest(props, ["Icon", "children", "popoverTitle", "title", "noTooltip", "iconOnly"]);
-    const renderIcon = iconOnly && !noTooltip ? React.createElement(Icon, { title: title }) : React.createElement(Icon, null);
-    const statusBody = (React.createElement(StatusIconAndText, Object.assign({}, restProps, { noTooltip: noTooltip, title: title, iconOnly: iconOnly, icon: renderIcon })));
-    return React.Children.toArray(children).length ? (React.createElement(PopoverStatus, Object.assign({ title: popoverTitle || title }, restProps, { statusBody: statusBody }), children)) : (statusBody);
+    const 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 Children.toArray(children).length ? (jsxRuntime.jsx(PopoverStatus, Object.assign({ title: popoverTitle || title }, restProps, { statusBody: statusBody }, { children: children }))) : (statusBody);
 };
 
 var checkCircleIcon = createCommonjsModule(function (module, exports) {
@@ -29086,65 +30402,46 @@ exports["default"] = exports.InfoCircleIcon;
 
 var InfoCircleIcon = /*@__PURE__*/getDefaultExportFromCjs(infoCircleIcon);
 
-const GreenCheckCircleIcon = ({ className, title, size }) => (React.createElement(Icon, { size: size, status: "success" },
-    React.createElement(CheckCircleIcon, { "data-test": "success-icon", className: className, title: title })));
+const GreenCheckCircleIcon = ({ className, title, size }) => (jsxRuntime.jsx(Icon, Object.assign({ size: size, status: "success" }, { children: jsxRuntime.jsx(CheckCircleIcon, { "data-test": "success-icon", className: className, title: title }) })));
 
-const SuccessStatus = (props) => (React.createElement(GenericStatus, Object.assign({}, props, { Icon: GreenCheckCircleIcon, title: props.title || 'Healthy' })));
+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 Status = ({ status, title, iconOnly, noTooltip, className }) => {
     const statusProps = { title: title || status, iconOnly, noTooltip, className };
     switch (status) {
         case 'In Progress':
-            return React.createElement(StatusIconAndText, Object.assign({}, statusProps, { icon: React.createElement(SyncAltIcon, null) }));
+            return jsxRuntime.jsx(StatusIconAndText, Object.assign({}, statusProps, { icon: jsxRuntime.jsx(SyncAltIcon, {}) }));
         case 'Complete':
-            return React.createElement(SuccessStatus, Object.assign({}, statusProps));
+            return jsxRuntime.jsx(SuccessStatus, Object.assign({}, statusProps));
         default:
-            return React.createElement(React.Fragment, null, status || DASH);
+            return jsxRuntime.jsx(jsxRuntime.Fragment, { children: status || DASH });
     }
 };
-const StatusIcon = ({ status }) => (React.createElement(Status, { status: status, iconOnly: true }));
+const StatusIcon = ({ status }) => jsxRuntime.jsx(Status, { status: status, iconOnly: true });
 
 const QuickStartTileDescription = ({ description, prerequisites, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
+    const { getResource } = useContext(QuickStartContext);
     const prereqs = prerequisites === null || prerequisites === void 0 ? void 0 : prerequisites.filter((p) => p);
-    const buttonRef = React.useRef(null);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(QuickStartMarkdownView, { content: description }),
-        (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (React.createElement(Flex, { spaceItems: { default: 'spaceItemsSm' } },
-            React.createElement("h5", null,
-                getResource('Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length),
-                ' '),
-            React.createElement(Button, { variant: "link", isInline: true, "data-testid": "qs-card-prereqs", ref: buttonRef, onClick: (e) => {
-                    e.preventDefault();
-                    e.stopPropagation();
-                }, "aria-label": getResource('Show prerequisites') },
-                React.createElement(InfoCircleIcon, null)),
-            React.createElement(Popover, { "aria-label": getResource('Prerequisites'), headerContent: getResource('Prerequisites'), triggerRef: buttonRef, bodyContent: React.createElement("div", null,
-                    React.createElement("ul", { "aria-label": getResource('Prerequisites') }, prereqs.map((prerequisite, index) => (
-                    // eslint-disable-next-line react/no-array-index-key
-                    React.createElement("li", { key: index },
-                        React.createElement(QuickStartMarkdownView, { content: prerequisite })))))) })))));
+    const buttonRef = useRef(null);
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: description }), (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (jsxRuntime.jsxs(Flex, Object.assign({ spaceItems: { default: 'spaceItemsSm' } }, { children: [jsxRuntime.jsxs("h5", { children: [getResource('Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), ' '] }), jsxRuntime.jsx(Button, Object.assign({ variant: "link", isInline: true, "data-testid": "qs-card-prereqs", ref: buttonRef, onClick: (e) => {
+                            e.preventDefault();
+                            e.stopPropagation();
+                        }, "aria-label": getResource('Show prerequisites') }, { children: jsxRuntime.jsx(InfoCircleIcon, {}) })), jsxRuntime.jsx(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.useContext(QuickStartContext);
-    const { activeQuickStartID, startQuickStart, restartQuickStart } = React.useContext(QuickStartContext);
-    const start = React.useCallback(() => {
+    const { getResource } = useContext(QuickStartContext);
+    const { activeQuickStartID, startQuickStart, restartQuickStart } = useContext(QuickStartContext);
+    const start = useCallback(() => {
         startQuickStart(quickStartId, totalTasks);
     }, [quickStartId, startQuickStart, totalTasks]);
-    const restart = React.useCallback(() => {
+    const restart = useCallback(() => {
         restartQuickStart(quickStartId, totalTasks);
     }, [quickStartId, restartQuickStart, totalTasks]);
-    return (React.createElement(Flex, { justifyContent: { default: 'justifyContentSpaceBetween' } },
-        status === QuickStartStatus.NOT_STARTED && (React.createElement(FlexItem, null,
-            React.createElement(Button, { onClick: start, variant: "link", isInline: true, "data-testid": "qs-card-notStarted-start", id: `${quickStartId}-start`, "aria-labelledby": `${quickStartId}-start ${quickStartId}` }, getResource('Start')))),
-        status === QuickStartStatus.IN_PROGRESS && activeQuickStartID !== quickStartId && (React.createElement(FlexItem, null,
-            React.createElement(Button, { variant: "link", onClick: onClickContinue, isInline: true, "data-testid": "qs-card-inProgress-resume", id: `${quickStartId}-continue`, "aria-labelledby": `${quickStartId}-continue ${quickStartId}` }, getResource('Continue')))),
-        status === QuickStartStatus.COMPLETE && (React.createElement(FlexItem, null,
-            React.createElement(Button, { onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-complete-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, getResource('Restart')))),
-        status === QuickStartStatus.IN_PROGRESS && (React.createElement(FlexItem, null,
-            React.createElement(Button, { onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-inProgress-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, getResource('Restart'))))));
+    return (jsxRuntime.jsxs(Flex, Object.assign({ justifyContent: { default: 'justifyContentSpaceBetween' } }, { children: [status === QuickStartStatus.NOT_STARTED && (jsxRuntime.jsx(FlexItem, { children: jsxRuntime.jsx(Button, Object.assign({ onClick: start, variant: "link", isInline: true, "data-testid": "qs-card-notStarted-start", id: `${quickStartId}-start`, "aria-labelledby": `${quickStartId}-start ${quickStartId}` }, { children: getResource('Start') })) })), status === QuickStartStatus.IN_PROGRESS && activeQuickStartID !== quickStartId && (jsxRuntime.jsx(FlexItem, { children: jsxRuntime.jsx(Button, Object.assign({ variant: "link", onClick: onClickContinue, isInline: true, "data-testid": "qs-card-inProgress-resume", id: `${quickStartId}-continue`, "aria-labelledby": `${quickStartId}-continue ${quickStartId}` }, { children: getResource('Continue') })) })), status === QuickStartStatus.COMPLETE && (jsxRuntime.jsx(FlexItem, { children: jsxRuntime.jsx(Button, Object.assign({ onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-complete-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, { children: getResource('Restart') })) })), status === QuickStartStatus.IN_PROGRESS && (jsxRuntime.jsx(FlexItem, { children: jsxRuntime.jsx(Button, Object.assign({ onClick: restart, variant: "link", isInline: true, "data-testid": "qs-card-inProgress-restart", id: `${quickStartId}-restart`, "aria-labelledby": `${quickStartId}-restart ${quickStartId}` }, { children: getResource('Restart') })) }))] })));
 };
 
 var externalLinkAltIcon = createCommonjsModule(function (module, exports) {
@@ -29163,15 +30460,12 @@ exports["default"] = exports.ExternalLinkAltIcon;
 
 var ExternalLinkAltIcon = /*@__PURE__*/getDefaultExportFromCjs(externalLinkAltIcon);
 
-const QuickStartTileFooterExternal = ({ link, quickStartId, }) => {
+const QuickStartTileFooterExternal = ({ link, quickStartId }) => {
     const { href, text } = link;
-    return (React.createElement(Flex, { justifyContent: { default: 'justifyContentSpaceBetween' } },
-        React.createElement(FlexItem, null,
-            React.createElement(Button, { component: "a", href: href, target: "_blank", rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: React.createElement(ExternalLinkAltIcon, null), iconPosition: "right", id: quickStartId, "aria-labelledby": `${quickStartId}-external ${quickStartId}` }, text || href))));
+    return (jsxRuntime.jsx(Flex, Object.assign({ justifyContent: { default: 'justifyContentSpaceBetween' } }, { children: jsxRuntime.jsx(FlexItem, { children: jsxRuntime.jsx(Button, Object.assign({ component: "a", href: href, target: "_blank", rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: jsxRuntime.jsx(ExternalLinkAltIcon, {}), iconPosition: "right", id: quickStartId, "aria-labelledby": `${quickStartId}-external ${quickStartId}` }, { children: text || href })) }) })));
 };
 
-const QuickStartTileHeader = ({ name, quickStartId, onSelect, }) => (React.createElement(Flex, { flexWrap: { default: 'nowrap' } },
-    React.createElement(Button, { "data-test": "title", id: quickStartId, variant: "link", isInline: true, onClick: onSelect }, name)));
+const QuickStartTileHeader = ({ name, quickStartId, onSelect }) => (jsxRuntime.jsx(Flex, Object.assign({ flexWrap: { default: 'nowrap' } }, { children: jsxRuntime.jsx(Button, Object.assign({ "data-test": "title", id: quickStartId, variant: "link", isInline: true, onClick: onSelect }, { children: name })) })));
 
 var outlinedBookmarkIcon = createCommonjsModule(function (module, exports) {
 exports.__esModule = true;
@@ -29207,7 +30501,7 @@ var OutlinedClockIcon = /*@__PURE__*/getDefaultExportFromCjs(outlinedClockIcon);
 
 const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, action, }) => {
     const { metadata: { name: id }, spec: { icon, tasks, displayName, description, durationMinutes, prerequisites, link, type }, } = quickStart;
-    const { setActiveQuickStart, footer, getResource } = React.useContext(QuickStartContext);
+    const { setActiveQuickStart, footer, getResource } = useContext(QuickStartContext);
     const statusColorMap = {
         [QuickStartStatus.COMPLETE]: 'green',
         [QuickStartStatus.IN_PROGRESS]: 'purple',
@@ -29220,11 +30514,10 @@ const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, act
     };
     let quickStartIcon;
     if (typeof icon === 'object') {
-        quickStartIcon = React.createElement(Icon, { size: "2xl" }, icon);
+        quickStartIcon = jsxRuntime.jsx(Icon, Object.assign({ size: "2xl" }, { children: icon }));
     }
     else {
-        quickStartIcon = (React.createElement(Icon, { size: "2xl" },
-            React.createElement(FallbackImg, { src: icon, alt: "", className: "pfext-catalog-item-icon__img", fallback: React.createElement(RocketIcon, null) })));
+        quickStartIcon = (jsxRuntime.jsx(Icon, Object.assign({ size: "2xl" }, { children: jsxRuntime.jsx(FallbackImg, { src: icon, alt: "", className: "pfext-catalog-item-icon__img", fallback: jsxRuntime.jsx(RocketIcon, {}) }) })));
     }
     const onSelect = () => {
         if (!link) {
@@ -29235,70 +30528,53 @@ const QuickStartTile = ({ quickStart, status, isActive, onClick = () => { }, act
         }
         onClick();
     };
-    const footerComponent = React.useMemo(() => {
+    const footerComponent = useMemo(() => {
         if (footer && footer.show === false) {
             return null;
         }
         if (link) {
-            return React.createElement(QuickStartTileFooterExternal, { link: link, quickStartId: id });
+            return jsxRuntime.jsx(QuickStartTileFooterExternal, { link: link, quickStartId: id });
         }
-        return (React.createElement(QuickStartTileFooter, { quickStartId: id, status: status, totalTasks: tasks === null || tasks === void 0 ? void 0 : tasks.length, onClickContinue: onSelect }));
+        return (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;
-    const additionalAction = action ? (React.createElement(Button, Object.assign({ "aria-label": action['aria-label'], icon: React.createElement(ActionIcon, null), variant: "plain", onClick: action.onClick }, action.buttonProps))) : undefined;
-    return (React.createElement(Card, Object.assign({ id: `${id}-catalog-tile`, style: { height: '100%' }, "data-testid": `qs-card-${camelize(displayName)}`, className: "pfext-catalog-item" }, (isActive && {
+    const additionalAction = action ? (jsxRuntime.jsx(Button, Object.assign({ "aria-label": action['aria-label'], icon: jsxRuntime.jsx(ActionIcon, {}), variant: "plain", onClick: action.onClick }, action.buttonProps))) : undefined;
+    return (jsxRuntime.jsxs(Card, Object.assign({ id: `${id}-catalog-tile`, style: { height: '100%' }, "data-testid": `qs-card-${camelize(displayName)}`, className: "pfext-catalog-item" }, (isActive && {
         isClickable: true,
         isSelectable: true,
         isSelected: true,
         isClicked: true,
-    })),
-        React.createElement(CardHeader, Object.assign({}, (action && {
-            actions: { actions: additionalAction },
-        })), quickStartIcon),
-        React.createElement(CardTitle, null,
-            React.createElement(QuickStartTileHeader, { name: displayName, onSelect: onSelect, quickStartId: id })),
-        React.createElement(CardBody, null,
-            React.createElement(Stack, { hasGutter: true },
-                React.createElement(Flex, { spaceItems: { default: 'spaceItemsSm' } },
-                    type && React.createElement(Label, { color: type.color }, type.text),
-                    durationMinutes && (React.createElement(Label, { variant: "outline", "data-test": "duration", icon: React.createElement(OutlinedClockIcon, null) }, getResource('{{duration, number}} minutes', durationMinutes).replace('{{duration, number}}', durationMinutes))),
-                    status !== QuickStartStatus.NOT_STARTED && (React.createElement(Label, { variant: "outline", color: statusColorMap[status], icon: React.createElement(StatusIcon, { status: status }), "data-test": "status" }, statusLocaleMap[status]))),
-                React.createElement(QuickStartTileDescription, { description: description, prerequisites: prerequisites }))),
-        React.createElement(CardFooter, null, footerComponent)));
+    }), { children: [jsxRuntime.jsx(CardHeader, Object.assign({}, (action && {
+                actions: { actions: additionalAction },
+            }), { children: quickStartIcon })), jsxRuntime.jsx(CardTitle, { children: jsxRuntime.jsx(QuickStartTileHeader, { name: displayName, onSelect: onSelect, quickStartId: id }) }), jsxRuntime.jsx(CardBody, { children: jsxRuntime.jsxs(Stack, Object.assign({ hasGutter: true }, { children: [jsxRuntime.jsxs(Flex, Object.assign({ spaceItems: { default: 'spaceItemsSm' } }, { children: [type && jsxRuntime.jsx(Label, Object.assign({ color: type.color }, { children: type.text })), durationMinutes && (jsxRuntime.jsx(Label, Object.assign({ variant: "outline", "data-test": "duration", icon: jsxRuntime.jsx(OutlinedClockIcon, {}) }, { children: getResource('{{duration, number}} minutes', durationMinutes).replace('{{duration, number}}', durationMinutes) }))), status !== QuickStartStatus.NOT_STARTED && (jsxRuntime.jsx(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(CardFooter, { children: footerComponent })] })));
 };
 
 const QuickStartCatalog = ({ quickStarts }) => {
-    const { activeQuickStartID, allQuickStartStates } = React.useContext(QuickStartContext);
-    return (React.createElement("div", null,
-        React.createElement(Gallery, { hasGutter: true, className: "pfext-quick-start-catalog__gallery" }, quickStarts.map((quickStart, index) => {
-            const { metadata: { name: id }, } = quickStart;
-            return (React.createElement(QuickStartTile, { key: index, quickStart: quickStart, isActive: id === activeQuickStartID, status: getQuickStartStatus(allQuickStartStates, id) }));
-        }))));
+    const { activeQuickStartID, allQuickStartStates } = useContext(QuickStartContext);
+    return (jsxRuntime.jsx("div", { children: jsxRuntime.jsx(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 = __rest(_a, ["searchInputText", "handleTextChange"]);
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(ToolbarItem, null,
-        React.createElement(SearchInput, Object.assign({ placeholder: getResource('Filter by keyword...'), value: searchInputText, onChange: (_ev, value) => handleTextChange(value), onClear: () => handleTextChange('') }, props))));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxRuntime.jsx(ToolbarItem, { children: jsxRuntime.jsx(SearchInput, Object.assign({ placeholder: getResource('Filter by keyword...'), value: searchInputText, onChange: (_ev, value) => handleTextChange(value), onClear: () => handleTextChange('') }, props)) }));
 };
 const QuickStartCatalogFilterSelect = (_a) => {
     var { isDropdownOpen, setIsDropdownOpen, onRowfilterSelect, selectedFilters, dropdownItems } = _a, props = __rest(_a, ["isDropdownOpen", "setIsDropdownOpen", "onRowfilterSelect", "selectedFilters", "dropdownItems"]);
-    const { getResource } = React.useContext(QuickStartContext);
-    const toggle = (toggleRef) => (React.createElement(MenuToggle, { isFullWidth: true, ref: toggleRef, onClick: () => setIsDropdownOpen(!isDropdownOpen), isExpanded: isDropdownOpen },
-        getResource('Status'),
-        selectedFilters.length > 0 && React.createElement(Badge, { isRead: true }, selectedFilters.length)));
-    return (React.createElement(ToolbarItem, null,
-        React.createElement(Select, Object.assign({ "aria-label": getResource('Select filter'), isOpen: isDropdownOpen, selected: selectedFilters, onSelect: onRowfilterSelect, onOpenChange: (isOpen) => setIsDropdownOpen(isOpen), toggle: toggle }, props),
-            React.createElement(SelectList, null, dropdownItems))));
+    const { getResource } = useContext(QuickStartContext);
+    const toggle = (toggleRef) => (jsxRuntime.jsxs(MenuToggle, Object.assign({ isFullWidth: true, ref: toggleRef, onClick: () => setIsDropdownOpen(!isDropdownOpen), isExpanded: isDropdownOpen }, { children: [getResource('Status'), selectedFilters.length > 0 && jsxRuntime.jsx(Badge, Object.assign({ isRead: true }, { children: selectedFilters.length }))] })));
+    return (jsxRuntime.jsx(ToolbarItem, { children: jsxRuntime.jsx(Select, Object.assign({ "aria-label": getResource('Select filter'), isOpen: isDropdownOpen, selected: selectedFilters, onSelect: onRowfilterSelect, onOpenChange: (isOpen) => setIsDropdownOpen(isOpen), toggle: toggle }, props, { children: jsxRuntime.jsx(SelectList, { children: dropdownItems }) })) }));
 };
 const QuickStartCatalogFilterCount = ({ quickStartsCount }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(ToolbarItem, { align: { default: 'alignEnd' } }, getResource('{{count, number}} item', quickStartsCount).replace('{{count, number}}', quickStartsCount)));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxRuntime.jsx(ToolbarItem, Object.assign({ align: { default: 'alignEnd' } }, { children: getResource('{{count, number}} item', quickStartsCount).replace('{{count, number}}', quickStartsCount) })));
 };
 const QuickStartCatalogFilterSearchWrapper = ({ onSearchInputChange = () => { } }) => {
-    const { useQueryParams, filter, setFilter } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const { useQueryParams, filter, setFilter } = useContext(QuickStartContext);
+    useEffect(() => {
         //   use this effect to clear the search when a `clear all` action is performed higher up
         const unlisten = history.listen(({ location }) => {
             const searchParams = new URLSearchParams(location.search);
@@ -29324,7 +30600,7 @@ const QuickStartCatalogFilterSearchWrapper = ({ onSearchInputChange = () => { }
         }
         onSearchInputChange(val);
     };
-    return (React.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) => {
@@ -29342,8 +30618,8 @@ const equalsIgnoreOrder = (a, b) => {
     return true;
 };
 const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) => {
-    const { useQueryParams, filter, setFilter } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const { useQueryParams, filter, setFilter } = useContext(QuickStartContext);
+    useEffect(() => {
         //   use this effect to clear the status when a `clear all` action is performed higher up
         const unlisten = history.listen(({ location }) => {
             var _a;
@@ -29358,8 +30634,8 @@ const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) =>
             unlisten();
         };
     });
-    const [isDropdownOpen, setIsDropdownOpen] = React.useState(false);
-    const onRowfilterSelect = React.useCallback((_e, selectedValue) => {
+    const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+    const onRowfilterSelect = useCallback((_e, selectedValue) => {
         setIsDropdownOpen(false);
         const selection = Object.entries(filter.status.statusTypes).find(([_key, value]) => value === selectedValue)[0];
         const selectedFiltersList = filter.status.statusFilters.includes(selection)
@@ -29376,33 +30652,24 @@ const QuickStartCatalogFilterStatusWrapper = ({ onStatusChange = () => { } }) =>
         }
         onStatusChange(selectedFiltersList);
     }, [filter.status.statusFilters, onStatusChange, setFilter, useQueryParams]);
-    const dropdownItems = Object.entries(filter.status.statusTypes).map(([key, value]) => (React.createElement(SelectOption, { key: key, "data-key": key, value: value, hasCheckbox: true, isSelected: filter.status.statusFilters.includes(key) },
-        React.createElement(React.Fragment, null, value))));
-    return (React.createElement(QuickStartCatalogFilterSelect, { isDropdownOpen: isDropdownOpen, setIsDropdownOpen: setIsDropdownOpen, onRowfilterSelect: onRowfilterSelect, selectedFilters: filter.status.statusFilters, dropdownItems: dropdownItems }));
+    const dropdownItems = Object.entries(filter.status.statusTypes).map(([key, value]) => (jsxRuntime.jsx(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.createElement(QuickStartCatalogFilterCount, { quickStartsCount: quickStartsCount });
+const QuickStartCatalogFilterCountWrapper = ({ quickStartsCount, }) => jsxRuntime.jsx(QuickStartCatalogFilterCount, { quickStartsCount: quickStartsCount });
 
 const QuickStartCatalogFilter = (_a) => {
     var { quickStartsCount, onSearchInputChange = () => { }, onStatusChange = () => { } } = _a, props = __rest(_a, ["quickStartsCount", "onSearchInputChange", "onStatusChange"]);
-    return (React.createElement(Toolbar, Object.assign({}, props),
-        React.createElement(ToolbarContent, null,
-            React.createElement(QuickStartCatalogFilterSearchWrapper, { onSearchInputChange: onSearchInputChange }),
-            React.createElement(QuickStartCatalogFilterStatusWrapper, { onStatusChange: onStatusChange }),
-            React.createElement(QuickStartCatalogFilterCountWrapper, { quickStartsCount: quickStartsCount }))));
+    return (jsxRuntime.jsx(Toolbar, Object.assign({}, props, { children: jsxRuntime.jsxs(ToolbarContent, { children: [jsxRuntime.jsx(QuickStartCatalogFilterSearchWrapper, { onSearchInputChange: onSearchInputChange }), jsxRuntime.jsx(QuickStartCatalogFilterStatusWrapper, { onStatusChange: onStatusChange }), jsxRuntime.jsx(QuickStartCatalogFilterCountWrapper, { quickStartsCount: quickStartsCount })] }) })));
 };
 
 const QuickStartCatalogEmptyState = ({ clearFilters }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(EmptyState, { headingLevel: "h4", icon: SearchIcon, titleText: React.createElement(React.Fragment, null, getResource('No results found')) },
-        React.createElement(EmptyStateBody, null, getResource('No results match the filter criteria. Remove filters or clear all filters to show results.')),
-        React.createElement(EmptyStateFooter, null,
-            React.createElement(EmptyStateActions, null,
-                React.createElement(Button, { variant: "link", onClick: clearFilters, "data-test": "clear-filter button" }, getResource('Clear all filters'))))));
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxRuntime.jsxs(EmptyState, Object.assign({ headingLevel: "h4", icon: SearchIcon, titleText: jsxRuntime.jsx(jsxRuntime.Fragment, { children: getResource('No results found') }) }, { children: [jsxRuntime.jsx(EmptyStateBody, { children: getResource('No results match the filter criteria. Remove filters or clear all filters to show results.') }), jsxRuntime.jsx(EmptyStateFooter, { children: jsxRuntime.jsx(EmptyStateActions, { children: jsxRuntime.jsx(Button, Object.assign({ variant: "link", onClick: clearFilters, "data-test": "clear-filter button" }, { children: getResource('Clear all filters') })) }) })] })));
 };
 const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) => q1.spec.displayName.localeCompare(q2.spec.displayName), title, hint, showTitle = true, }) => {
-    const sortFncCallback = React.useCallback(sortFnc, [sortFnc]);
-    const { allQuickStarts = [], setAllQuickStarts, allQuickStartStates, getResource, filter, setFilter, loading, } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const sortFncCallback = useCallback(sortFnc, [sortFnc]);
+    const { allQuickStarts = [], setAllQuickStarts, allQuickStartStates, getResource, filter, setFilter, loading, } = useContext(QuickStartContext);
+    useEffect(() => {
         // passed through prop, not context
         if (quickStarts && JSON.stringify(quickStarts) !== JSON.stringify(allQuickStarts)) {
             setAllQuickStarts(quickStarts);
@@ -29411,8 +30678,8 @@ const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) =>
     const initialFilteredQuickStarts = showFilter
         ? filterQuickStarts(allQuickStarts, filter.keyword, filter.status.statusFilters, allQuickStartStates).sort(sortFncCallback)
         : allQuickStarts;
-    const [filteredQuickStarts, setFilteredQuickStarts] = React.useState(initialFilteredQuickStarts);
-    React.useEffect(() => {
+    const [filteredQuickStarts, setFilteredQuickStarts] = useState(initialFilteredQuickStarts);
+    useEffect(() => {
         const filteredQs = showFilter
             ? filterQuickStarts(allQuickStarts, filter.keyword, filter.status.statusFilters, allQuickStartStates).sort(sortFncCallback)
             : allQuickStarts;
@@ -29455,37 +30722,23 @@ const QuickStartCatalogPage = ({ quickStarts, showFilter, sortFnc = (q1, q2) =>
         }
     };
     if (loading) {
-        return React.createElement(LoadingBox, null);
+        return jsxRuntime.jsx(LoadingBox, {});
     }
     if (!allQuickStarts || allQuickStarts.length === 0) {
-        return React.createElement(EmptyBox, { label: getResource('Quick Starts') });
+        return jsxRuntime.jsx(EmptyBox, { label: getResource('Quick Starts') });
     }
-    return (React.createElement(React.Fragment, null,
-        (showTitle || showFilter) && (React.createElement(PageSection, { hasBodyWrapper: false },
-            showTitle && (React.createElement(Content, { isEditorial: true },
-                React.createElement(Title, { headingLevel: "h1", "data-test": "page-title" }, title || getResource('Quick Starts')),
-                hint && React.createElement("div", null, hint))),
-            showTitle && React.createElement(Divider, { component: "div" }),
-            showFilter && (React.createElement(React.Fragment, null,
-                React.createElement(QuickStartCatalogFilter, { quickStartsCount: filteredQuickStarts.length, onSearchInputChange: onSearchInputChange, onStatusChange: onStatusChange }))))),
-        React.createElement(PageSection, { hasBodyWrapper: false }, filteredQuickStarts.length === 0 ? (React.createElement(QuickStartCatalogEmptyState, { clearFilters: clearFilters })) : (React.createElement(QuickStartCatalog, { quickStarts: filteredQuickStarts })))));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [(showTitle || showFilter) && (jsxRuntime.jsxs(PageSection, Object.assign({ hasBodyWrapper: false }, { children: [showTitle && (jsxRuntime.jsxs(Content, Object.assign({ isEditorial: true }, { children: [jsxRuntime.jsx(Title, Object.assign({ headingLevel: "h1", "data-test": "page-title" }, { children: title || getResource('Quick Starts') })), hint && jsxRuntime.jsx("div", { children: hint })] }))), showTitle && jsxRuntime.jsx(Divider, { component: "div" }), showFilter && (jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxRuntime.jsx(QuickStartCatalogFilter, { quickStartsCount: filteredQuickStarts.length, onSearchInputChange: onSearchInputChange, onStatusChange: onStatusChange }) }))] }))), jsxRuntime.jsx(PageSection, Object.assign({ hasBodyWrapper: false }, { children: filteredQuickStarts.length === 0 ? (jsxRuntime.jsx(QuickStartCatalogEmptyState, { clearFilters: clearFilters })) : (jsxRuntime.jsx(QuickStartCatalog, { quickStarts: filteredQuickStarts })) }))] }));
 };
 
-const QuickStartCatalogHeader = ({ title, hint, }) => (React.createElement("div", null,
-    React.createElement(Title, { headingLevel: "h1", "data-pf-content": "true" }, title),
-    hint && React.createElement("div", null, hint)));
+const QuickStartCatalogHeader = ({ title, hint, }) => (jsxRuntime.jsxs("div", { children: [jsxRuntime.jsx(Title, Object.assign({ headingLevel: "h1", "data-pf-content": "true" }, { children: title })), hint && jsxRuntime.jsx("div", { children: hint })] }));
 
-const QuickStartCatalogSection = ({ children }) => (React.createElement("div", null, children));
+const QuickStartCatalogSection = ({ children }) => (jsxRuntime.jsx("div", { children: children }));
 
-const QuickStartCatalogToolbar = ({ children }) => (React.createElement(Toolbar, null, children));
+const QuickStartCatalogToolbar = ({ children }) => (jsxRuntime.jsx(Toolbar, { children: children }));
 
-const QuickStartCloseModal = ({ isOpen, onConfirm, onCancel, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(Modal, { isOpen: isOpen, variant: ModalVariant.small, showClose: false, "data-test": "leave-quickstart", title: getResource('Leave quick start?'), footer: React.createElement(Flex, null,
-            React.createElement(FlexItem, { align: { default: 'alignRight' } },
-                React.createElement(Button, { variant: "secondary", "data-test": "cancel button", onClick: onCancel }, getResource('Cancel'))),
-            React.createElement(FlexItem, null,
-                React.createElement(Button, { variant: "primary", "data-test": "leave button", onClick: onConfirm }, getResource('Leave')))), isFullScreen: true }, getResource('Your progress will be saved.')));
+const QuickStartCloseModal = ({ isOpen, onConfirm, onCancel }) => {
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxRuntime.jsx(Modal, Object.assign({ isOpen: isOpen, variant: ModalVariant.small, showClose: false, "data-test": "leave-quickstart", title: getResource('Leave quick start?'), footer: jsxRuntime.jsxs(Flex, { children: [jsxRuntime.jsx(FlexItem, Object.assign({ align: { default: 'alignRight' } }, { children: jsxRuntime.jsx(Button, Object.assign({ variant: "secondary", "data-test": "cancel button", onClick: onCancel }, { children: getResource('Cancel') })) })), jsxRuntime.jsx(FlexItem, { children: jsxRuntime.jsx(Button, Object.assign({ variant: "primary", "data-test": "leave button", onClick: onConfirm }, { children: getResource('Leave') })) })] }), isFullScreen: true }, { children: getResource('Your progress will be saved.') })));
 };
 
 var arrowRightIcon = createCommonjsModule(function (module, exports) {
@@ -29505,25 +30758,17 @@ exports["default"] = exports.ArrowRightIcon;
 var ArrowRightIcon = /*@__PURE__*/getDefaultExportFromCjs(arrowRightIcon);
 
 const QuickStartTaskHeader = ({ title, taskIndex, subtitle, taskStatus, size, isActiveTask, onTaskSelect, children, }) => {
-    const titleRef = React.useRef(null);
-    const { focusOnQuickStart } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const titleRef = useRef(null);
+    const { focusOnQuickStart } = useContext(QuickStartContext);
+    useEffect(() => {
         if (focusOnQuickStart && isActiveTask) {
             // Focus the WizardNavItem button element that contains the title
             titleRef.current.parentNode.focus();
         }
     }, [focusOnQuickStart, isActiveTask]);
     const failedReview = taskStatus === QuickStartTaskStatus.FAILED;
-    const tryAgain = failedReview && (React.createElement(React.Fragment, null,
-        React.createElement("div", null),
-        React.createElement("div", { className: "pfext-quick-start-task-header__tryagain" }, "Try the steps again.")));
-    const content = (React.createElement("div", { ref: titleRef },
-        React.createElement(Title, { headingLevel: "h3", size: size },
-            React.createElement("span", { className: "pfext-quick-start-task-header__title" }, title),
-            isActiveTask && subtitle && (React.createElement("span", null,
-                ' ',
-                React.createElement("span", { "data-test-id": "quick-start-task-subtitle", className: "pfext-quick-start-task-header__subtitle" }, subtitle))),
-            tryAgain)));
+    const tryAgain = failedReview && (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(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 === QuickStartTaskStatus.FAILED) {
         status = 'error';
@@ -29531,42 +30776,31 @@ const QuickStartTaskHeader = ({ title, taskIndex, subtitle, taskStatus, size, is
     else if (taskStatus === QuickStartTaskStatus.SUCCESS) {
         status = 'success';
     }
-    return (React.createElement(WizardNavItem, { content: content, stepIndex: taskIndex, onClick: () => onTaskSelect(taskIndex - 1), component: "button", isCurrent: isActiveTask, status: status, className: "pfext-quick-start-task-header" }, children));
+    return (jsxRuntime.jsx(WizardNavItem, Object.assign({ content: content, stepIndex: taskIndex, onClick: () => onTaskSelect(taskIndex - 1), component: "button", isCurrent: isActiveTask, status: status, className: "pfext-quick-start-task-header" }, { children: children })));
 };
 
-const QuickStartTaskHeaderList = ({ tasks, allTaskStatuses, onTaskSelect, }) => (tasks === null || tasks === void 0 ? void 0 : tasks.length) > 0 ? (React.createElement("ul", { className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list" }, tasks.map((task, index) => (React.createElement(QuickStartTaskHeader, { key: task.title, title: task.title, taskIndex: index + 1, size: "md", taskStatus: allTaskStatuses[index], onTaskSelect: onTaskSelect }))))) : null;
+const QuickStartTaskHeaderList = ({ tasks, allTaskStatuses, onTaskSelect, }) => (tasks === null || tasks === void 0 ? void 0 : tasks.length) > 0 ? (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(QuickStartTaskStatus.FAILED);
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect }),
-        React.createElement(QuickStartMarkdownView, { content: hasFailedTask
-                ? getResource('One or more verifications did not pass during this quick start. Revisit the tasks or the help links, and then try again.')
-                : conclusion }),
-        !hasFailedTask &&
-            nextQuickStarts &&
-            nextQuickStarts.length > 0 &&
-            nextQuickStarts.map((nextQuickStart, index) => {
-                var _a;
-                return (React.createElement(Button, { variant: "link", onClick: () => onQuickStartChange(nextQuickStart.metadata.name), isInline: true, icon: React.createElement(ArrowRightIcon, null), iconPosition: "end", isBlock: true, key: index, style: { marginTop: 'var(--pf-t--global--spacer--md' } }, getResource('Start {{nextQSDisplayName}} quick start').replace('{{nextQSDisplayName}}', (_a = nextQuickStart === null || nextQuickStart === void 0 ? void 0 : nextQuickStart.spec) === null || _a === void 0 ? void 0 : _a.displayName)));
-            })));
+    const { getResource } = useContext(QuickStartContext);
+    return (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(Button, Object.assign({ variant: "link", onClick: () => onQuickStartChange(nextQuickStart.metadata.name), isInline: true, icon: jsxRuntime.jsx(ArrowRightIcon, {}), iconPosition: "end", isBlock: true, style: { marginTop: 'var(--pf-t--global--spacer--md' } }, { children: getResource('Start {{nextQSDisplayName}} quick start').replace('{{nextQSDisplayName}}', (_a = nextQuickStart === null || nextQuickStart === void 0 ? void 0 : nextQuickStart.spec) === null || _a === void 0 ? void 0 : _a.displayName) }), index));
+                })] }));
 };
 
 const QuickStartIntroduction = ({ tasks, introduction, allTaskStatuses, prerequisites, onTaskSelect, }) => {
-    const { getResource } = React.useContext(QuickStartContext);
+    const { getResource } = useContext(QuickStartContext);
     const prereqs = prerequisites === null || prerequisites === void 0 ? void 0 : prerequisites.filter((p) => p);
-    const [isPrereqsExpanded, setIsPrereqsExpanded] = React.useState(false);
-    const prereqList = (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (React.createElement(ExpandableSection, { toggleText: getResource('View Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), onToggle: () => setIsPrereqsExpanded(!isPrereqsExpanded) },
-        React.createElement(List, null, prereqs.map((pr) => (React.createElement(ListItem, { key: pr },
-            React.createElement(QuickStartMarkdownView, { content: pr })))))));
-    return (React.createElement(Stack, { hasGutter: true },
-        React.createElement(QuickStartMarkdownView, { content: introduction }),
-        prereqList,
-        React.createElement("p", null,
-            getResource('In this quick start, you will complete {{count, number}} task', tasks === null || tasks === void 0 ? void 0 : tasks.length).replace('{{count, number}}', (tasks === null || tasks === void 0 ? void 0 : tasks.length) || 0),
-            ":"),
-        React.createElement(QuickStartTaskHeaderList, { tasks: tasks, allTaskStatuses: allTaskStatuses, onTaskSelect: onTaskSelect })));
+    const [isPrereqsExpanded, setIsPrereqsExpanded] = useState(false);
+    const prereqList = (prereqs === null || prereqs === void 0 ? void 0 : prereqs.length) > 0 && (jsxRuntime.jsx(ExpandableSection, Object.assign({ toggleText: getResource('View Prerequisites ({{totalPrereqs}})').replace('{{totalPrereqs}}', prereqs.length), onToggle: () => setIsPrereqsExpanded(!isPrereqsExpanded) }, { children: jsxRuntime.jsx(List, { children: prereqs.map((pr) => (jsxRuntime.jsx(ListItem, { children: jsxRuntime.jsx(QuickStartMarkdownView, { content: pr }) }, pr))) }) })));
+    return (jsxRuntime.jsxs(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).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) => {
@@ -29581,64 +30815,52 @@ const getAlertVariant = (status) => {
 };
 const QuickStartTaskReview = ({ review, taskStatus, onTaskReview, }) => {
     const { instructions, failedTaskHelp: taskHelp } = review;
-    const { getResource } = React.useContext(QuickStartContext);
-    return (React.createElement(Alert, { variant: getAlertVariant(taskStatus), title: getResource('Check your work'), isInline: true, role: "alert", style: {
+    const { getResource } = useContext(QuickStartContext);
+    return (jsxRuntime.jsxs(Alert, Object.assign({ variant: getAlertVariant(taskStatus), title: getResource('Check your work'), isInline: true, role: "alert", style: {
             marginBottom: 'var(--pf-t--global--spacer--md)',
-        } },
-        React.createElement(QuickStartMarkdownView, { content: instructions }),
-        React.createElement("span", { className: "pfext-quick-start-task-review__actions" },
-            React.createElement(Radio, { id: "review-success", name: "review-success", "data-testid": "qs-drawer-check-yes", label: getResource('Yes'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.SUCCESS, onChange: () => onTaskReview(QuickStartTaskStatus.SUCCESS) }),
-            React.createElement(Radio, { id: "review-failed", name: "review-failed", "data-testid": "qs-drawer-check-no", label: getResource('No'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.FAILED, onChange: () => onTaskReview(QuickStartTaskStatus.FAILED) })),
-        taskStatus === QuickStartTaskStatus.FAILED && taskHelp && (React.createElement(QuickStartMarkdownView, { content: taskHelp, exactHeight: true }))));
+        } }, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: instructions }), jsxRuntime.jsxs("span", Object.assign({ className: "pfext-quick-start-task-review__actions" }, { children: [jsxRuntime.jsx(Radio, { id: "review-success", name: "review-success", "data-testid": "qs-drawer-check-yes", label: getResource('Yes'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.SUCCESS, onChange: () => onTaskReview(QuickStartTaskStatus.SUCCESS) }), jsxRuntime.jsx(Radio, { id: "review-failed", name: "review-failed", "data-testid": "qs-drawer-check-no", label: getResource('No'), className: "pfext-quick-start-task-review__radio", isChecked: taskStatus === QuickStartTaskStatus.FAILED, onChange: () => onTaskReview(QuickStartTaskStatus.FAILED) })] })), taskStatus === QuickStartTaskStatus.FAILED && taskHelp && (jsxRuntime.jsx(QuickStartMarkdownView, { content: taskHelp, exactHeight: true }))] })));
 };
 
 const QuickStartTasks = ({ tasks, taskNumber, allTaskStatuses, onTaskReview, onTaskSelect, }) => {
-    const { getResource, alwaysShowTaskReview } = React.useContext(QuickStartContext);
-    return (React.createElement("div", { className: "pf-v6-c-wizard pf-v6-c-wizard__nav-list", style: { padding: '0 0 0 0' } },
-        React.createElement("ul", null, tasks
-            .filter((_, index) => allTaskStatuses[index] !== QuickStartTaskStatus.INIT)
-            .map((task, index) => {
-            const { title, description, review } = task;
-            const isActiveTask = index === taskNumber;
-            const taskStatus = allTaskStatuses[index];
-            const shouldShowTaskReview = (!QUICKSTART_TASKS_INITIAL_STATES.includes(taskStatus) || alwaysShowTaskReview) &&
-                review;
-            return (React.createElement(React.Fragment, { key: title },
-                React.createElement(QuickStartTaskHeader, { taskIndex: index + 1, title: title, size: "md", subtitle: getResource('{{index, number}} of {{tasks, number}}')
-                        .replace('{{index, number}}', index + 1)
-                        .replace('{{tasks, number}}', tasks.length), taskStatus: taskStatus, isActiveTask: isActiveTask, onTaskSelect: onTaskSelect }, isActiveTask && (React.createElement(Stack, { hasGutter: true },
-                    React.createElement(QuickStartMarkdownView, { content: description }),
-                    shouldShowTaskReview && (React.createElement(QuickStartTaskReview, { review: review, taskStatus: taskStatus, onTaskReview: onTaskReview })))))));
-        }))));
-};
-
-const QuickStartContent = React.forwardRef(({ quickStart, nextQuickStarts = [], taskNumber, allTaskStatuses, onTaskSelect, onTaskReview, onQuickStartChange, }, ref) => {
+    const { getResource, alwaysShowTaskReview } = useContext(QuickStartContext);
+    return (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] !== 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(Fragment$1, { 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(Stack, Object.assign({ hasGutter: true }, { children: [jsxRuntime.jsx(QuickStartMarkdownView, { content: description }), shouldShowTaskReview && (jsxRuntime.jsx(QuickStartTaskReview, { review: review, taskStatus: taskStatus, onTaskReview: onTaskReview }))] }))) })) }, title));
+            }) }) })));
+};
+
+const QuickStartContent = forwardRef(({ quickStart, nextQuickStarts = [], taskNumber, allTaskStatuses, onTaskSelect, onTaskReview, onQuickStartChange, }, ref) => {
     const { spec: { introduction, tasks, conclusion, prerequisites }, } = quickStart;
     const totalTasks = tasks === null || tasks === void 0 ? void 0 : tasks.length;
-    return (React.createElement("div", { className: "pfext-quick-start-task", ref: ref },
-        taskNumber === -1 && (React.createElement(QuickStartIntroduction, { tasks: tasks, allTaskStatuses: allTaskStatuses, introduction: introduction, prerequisites: prerequisites, onTaskSelect: onTaskSelect })),
-        taskNumber > -1 && taskNumber < totalTasks && (React.createElement(QuickStartTasks, { tasks: tasks, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskReview: onTaskReview, onTaskSelect: onTaskSelect })),
-        taskNumber === totalTasks && (React.createElement(QuickStartConclusion, { tasks: tasks, conclusion: conclusion, allTaskStatuses: allTaskStatuses, nextQuickStarts: nextQuickStarts, onQuickStartChange: onQuickStartChange, onTaskSelect: onTaskSelect }))));
+    return (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.useContext(QuickStartContext);
-    const PrimaryButtonText = React.useMemo(() => ({
+    const { restartQuickStart, getResource } = useContext(QuickStartContext);
+    const PrimaryButtonText = useMemo(() => ({
         START: getResource('Start'),
         CONTINUE: getResource('Continue'),
         NEXT: getResource('Next'),
         CLOSE: getResource('Close'),
     }), [getResource]);
-    const SecondaryButtonText = React.useMemo(() => ({
+    const SecondaryButtonText = useMemo(() => ({
         BACK: getResource('Back'),
         RESTART: getResource('Restart'),
     }), [getResource]);
-    const onRestart = React.useCallback((e) => {
+    const onRestart = useCallback((e) => {
         e.preventDefault();
         e.stopPropagation();
         restartQuickStart(quickStartId, totalTasks);
     }, [quickStartId, restartQuickStart, totalTasks]);
-    const getPrimaryButtonText = React.useMemo(() => {
+    const getPrimaryButtonText = useMemo(() => {
         if (status === QuickStartStatus.NOT_STARTED) {
             return PrimaryButtonText.START;
         }
@@ -29650,23 +30872,17 @@ const QuickStartFooter = ({ status, taskNumber, totalTasks, onNext, onBack, quic
         }
         return PrimaryButtonText.CONTINUE;
     }, [taskNumber, totalTasks, PrimaryButtonText, status]);
-    const getPrimaryButton = React.useMemo(() => (React.createElement(Button, { variant: "primary", className: "pfext-quick-start-footer__actionbtn", onClick: onNext, "data-testid": `qs-drawer-${camelize(getPrimaryButtonText)}`, "data-test": `${getPrimaryButtonText} button` }, getPrimaryButtonText)), [getPrimaryButtonText, onNext]);
-    const getSecondaryButton = React.useMemo(() => taskNumber === -1 && status !== QuickStartStatus.NOT_STARTED ? (React.createElement(Button, { variant: "secondary", onClick: onRestart, "data-testid": "qs-drawer-restart" }, SecondaryButtonText.RESTART)) : (taskNumber > -1 && (React.createElement(Button, { variant: "secondary", onClick: onBack, "data-testid": "qs-drawer-back" }, SecondaryButtonText.BACK))), [onRestart, onBack, SecondaryButtonText, status, taskNumber]);
-    const getSideNoteAction = React.useMemo(() => taskNumber !== -1 && (React.createElement(Button, { variant: "link", onClick: onRestart, "data-testid": "qs-drawer-side-note-action" }, SecondaryButtonText.RESTART)), [taskNumber, onRestart, SecondaryButtonText.RESTART]);
-    return (React.createElement("div", { className: css('pfext-quick-start-footer', className) },
-        React.createElement(ActionList, null,
-            React.createElement(ActionListGroup, null,
-                React.createElement(ActionListItem, null, getPrimaryButton),
-                React.createElement(ActionListItem, null, getSecondaryButton)),
-            React.createElement(ActionListGroup, null,
-                React.createElement(ActionListItem, null, getSideNoteAction)))));
+    const getPrimaryButton = useMemo(() => (jsxRuntime.jsx(Button, Object.assign({ variant: "primary", className: "pfext-quick-start-footer__actionbtn", onClick: onNext, "data-testid": `qs-drawer-${camelize(getPrimaryButtonText)}`, "data-test": `${getPrimaryButtonText} button` }, { children: getPrimaryButtonText }))), [getPrimaryButtonText, onNext]);
+    const getSecondaryButton = useMemo(() => taskNumber === -1 && status !== QuickStartStatus.NOT_STARTED ? (jsxRuntime.jsx(Button, Object.assign({ variant: "secondary", onClick: onRestart, "data-testid": "qs-drawer-restart" }, { children: SecondaryButtonText.RESTART }))) : (taskNumber > -1 && (jsxRuntime.jsx(Button, Object.assign({ variant: "secondary", onClick: onBack, "data-testid": "qs-drawer-back" }, { children: SecondaryButtonText.BACK })))), [onRestart, onBack, SecondaryButtonText, status, taskNumber]);
+    const getSideNoteAction = useMemo(() => taskNumber !== -1 && (jsxRuntime.jsx(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: css('pfext-quick-start-footer', className) }, { children: jsxRuntime.jsxs(ActionList, { children: [jsxRuntime.jsxs(ActionListGroup, { children: [jsxRuntime.jsx(ActionListItem, { children: getPrimaryButton }), jsxRuntime.jsx(ActionListItem, { children: getSecondaryButton })] }), jsxRuntime.jsx(ActionListGroup, { children: jsxRuntime.jsx(ActionListItem, { children: getSideNoteAction }) })] }) })));
 };
 
 const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerClass, }) => {
     const { metadata: { name }, spec: { tasks = [] }, } = quickStart;
     const totalTasks = tasks === null || tasks === void 0 ? void 0 : tasks.length;
-    const { activeQuickStartID, allQuickStartStates, setAllQuickStartStates, activeQuickStartState, setActiveQuickStart, setQuickStartTaskNumber, setQuickStartTaskStatus, nextStep, previousStep, } = React.useContext(QuickStartContext);
-    React.useEffect(() => {
+    const { activeQuickStartID, allQuickStartStates, setAllQuickStartStates, activeQuickStartState, setActiveQuickStart, setQuickStartTaskNumber, setQuickStartTaskStatus, nextStep, previousStep, } = useContext(QuickStartContext);
+    useEffect(() => {
         // If activeQuickStartID was changed through prop from QuickStartContainer, need to init the state if it does not exist yet
         if (activeQuickStartID && !allQuickStartStates[activeQuickStartID]) {
             setAllQuickStartStates(Object.assign(Object.assign({}, allQuickStartStates), { [activeQuickStartID]: getDefaultQuickStartState() }));
@@ -29675,9 +30891,9 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
     const status = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.status;
     const taskNumber = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.taskNumber;
     const allTaskStatuses = tasks.map((task, index) => activeQuickStartState[`taskStatus${index}`]);
-    const handleQuickStartChange = React.useCallback((quickStartId) => setActiveQuickStart(quickStartId), [setActiveQuickStart]);
-    const handleTaskStatusChange = React.useCallback((newTaskStatus) => setQuickStartTaskStatus(newTaskStatus), [setQuickStartTaskStatus]);
-    const getQuickStartActiveTask = React.useCallback(() => {
+    const handleQuickStartChange = useCallback((quickStartId) => setActiveQuickStart(quickStartId), [setActiveQuickStart]);
+    const handleTaskStatusChange = useCallback((newTaskStatus) => setQuickStartTaskStatus(newTaskStatus), [setQuickStartTaskStatus]);
+    const getQuickStartActiveTask = useCallback(() => {
         let activeTaskNumber = 0;
         while (activeTaskNumber !== totalTasks &&
             activeQuickStartState[`taskStatus${activeTaskNumber}`] === QuickStartTaskStatus.SUCCESS) {
@@ -29685,11 +30901,11 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
         }
         return activeTaskNumber;
     }, [totalTasks, activeQuickStartState]);
-    const handleQuickStartContinue = React.useCallback(() => {
+    const handleQuickStartContinue = useCallback(() => {
         const activeTaskNumber = getQuickStartActiveTask();
         setQuickStartTaskNumber(name, activeTaskNumber);
     }, [getQuickStartActiveTask, setQuickStartTaskNumber, name]);
-    const handleNext = React.useCallback(() => {
+    const handleNext = useCallback(() => {
         if (status === QuickStartStatus.COMPLETE && taskNumber === totalTasks) {
             return handleQuickStartChange('');
         }
@@ -29698,13 +30914,11 @@ const QuickStartController = ({ quickStart, nextQuickStarts, contentRef, footerC
         }
         return nextStep(totalTasks);
     }, [handleQuickStartChange, nextStep, status, taskNumber, totalTasks, handleQuickStartContinue]);
-    const handleBack = React.useCallback(() => previousStep(), [previousStep]);
-    const handleTaskSelect = React.useCallback((selectedTaskNumber) => {
+    const handleBack = useCallback(() => previousStep(), [previousStep]);
+    const handleTaskSelect = useCallback((selectedTaskNumber) => {
         setQuickStartTaskNumber(name, selectedTaskNumber);
     }, [name, setQuickStartTaskNumber]);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(QuickStartContent, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, taskNumber: taskNumber, allTaskStatuses: allTaskStatuses, onTaskSelect: handleTaskSelect, onTaskReview: handleTaskStatusChange, onQuickStartChange: handleQuickStartChange, ref: contentRef }),
-        React.createElement(QuickStartFooter, { status: status, taskNumber: taskNumber, totalTasks: totalTasks, onNext: handleNext, onBack: handleBack, className: footerClass, quickStartId: quickStart.metadata.name })));
+    return (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) => {
@@ -29714,7 +30928,7 @@ const getElement = (appendTo) => {
     return appendTo;
 };
 const useScrollTopOnTaskNumberChange = (node, taskNumber) => {
-    React.useEffect(() => {
+    useEffect(() => {
         if (node) {
             node.scrollTo({ top: 0, behavior: 'smooth' });
         }
@@ -29722,9 +30936,9 @@ const useScrollTopOnTaskNumberChange = (node, taskNumber) => {
 };
 const QuickStartPanelContent = (_a) => {
     var { quickStarts = [], handleClose, activeQuickStartID, appendTo, isResizable = true, showClose = true, footerClass } = _a, props = __rest(_a, ["quickStarts", "handleClose", "activeQuickStartID", "appendTo", "isResizable", "showClose", "footerClass"]);
-    const titleRef = React.useRef(null);
-    const { getResource, activeQuickStartState, focusOnQuickStart } = React.useContext(QuickStartContext);
-    const [contentRef, setContentRef] = React.useState();
+    const titleRef = useRef(null);
+    const { getResource, activeQuickStartState, focusOnQuickStart } = useContext(QuickStartContext);
+    const [contentRef, setContentRef] = useState();
     const quickStart = quickStarts.find((qs) => qs.metadata.name === activeQuickStartID);
     const taskNumber = activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.taskNumber;
     useScrollTopOnTaskNumberChange(contentRef, taskNumber);
@@ -29740,27 +30954,16 @@ const QuickStartPanelContent = (_a) => {
         }
         return Number.parseInt(taskNumber) + 1;
     };
-    React.useEffect(() => {
+    useEffect(() => {
         if (focusOnQuickStart && quickStart) {
             titleRef.current.focus();
         }
     }, [focusOnQuickStart, quickStart]);
-    const content = quickStart ? (React.createElement(DrawerPanelContent, Object.assign({ isResizable: isResizable, "data-testid": `qs-drawer-${camelize(quickStart.spec.displayName)}`, "data-qs": `qs-step-${getStep()}`, "data-test": "quickstart drawer", style: { '--pf-v6-c-drawer__panel--PaddingBlockStart': '0' } }, props),
-        React.createElement("div", { className: "pfext-quick-start-panel-content" },
-            React.createElement(DrawerHead, null,
-                React.createElement("div", { tabIndex: -1, ref: titleRef },
-                    React.createElement(Title, { headingLevel: "h2", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } },
-                        React.createElement("span", null, quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.displayName),
-                        ' '),
-                    React.createElement("span", null, (quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
-                        ? getResource('{{type}} • {{duration, number}} minutes', quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
-                            .replace('{{duration, number}}', quickStart === null || quickStart === void 0 ? void 0 : quickStart.spec.durationMinutes)
-                            .replace('{{type}}', getResource('Type'))
-                        : getResource('Type'))),
-                showClose && (React.createElement(DrawerActions, null,
-                    React.createElement(DrawerCloseButton, { onClick: handleClose, className: "pfext-quick-start-panel-content__close-button", "data-testid": "qs-drawer-close" }))))),
-        React.createElement(DrawerPanelBody, { className: "pfext-quick-start-panel-content__body", "data-test": "content" },
-            React.createElement(QuickStartController, { quickStart: quickStart, nextQuickStarts: nextQuickStarts, footerClass: footerClass, contentRef: setContentRef })))) : null;
+    const content = quickStart ? (jsxRuntime.jsxs(DrawerPanelContent, Object.assign({ isResizable: isResizable, "data-testid": `qs-drawer-${camelize(quickStart.spec.displayName)}`, "data-qs": `qs-step-${getStep()}`, "data-test": "quickstart drawer", style: { '--pf-v6-c-drawer__panel--PaddingBlockStart': '0' } }, props, { children: [jsxRuntime.jsx("div", Object.assign({ className: "pfext-quick-start-panel-content" }, { children: jsxRuntime.jsxs(DrawerHead, { children: [jsxRuntime.jsxs("div", Object.assign({ tabIndex: -1, ref: titleRef }, { children: [jsxRuntime.jsxs(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(DrawerActions, { children: jsxRuntime.jsx(DrawerCloseButton, { onClick: handleClose, className: "pfext-quick-start-panel-content__close-button", "data-testid": "qs-drawer-close" }) }))] }) })), jsxRuntime.jsx(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.createPortal(content, getElement(appendTo));
     }
@@ -29769,7 +30972,7 @@ const QuickStartPanelContent = (_a) => {
 
 const QuickStartDrawerContent = (_a) => {
     var { quickStarts = [], appendTo, fullWidth, handleDrawerClose } = _a, props = __rest(_a, ["quickStarts", "appendTo", "fullWidth", "handleDrawerClose"]);
-    const { activeQuickStartID, allQuickStarts = [], activeQuickStartState, } = React.useContext(QuickStartContext);
+    const { activeQuickStartID, allQuickStarts = [], activeQuickStartState, } = useContext(QuickStartContext);
     const combinedQuickStarts = allQuickStarts.concat(quickStarts);
     const handleClose = () => {
         handleDrawerClose && handleDrawerClose(activeQuickStartState === null || activeQuickStartState === void 0 ? void 0 : activeQuickStartState.status);
@@ -29781,14 +30984,14 @@ const QuickStartDrawerContent = (_a) => {
             },
         }
         : {};
-    return (React.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 = __rest(_a, ["quickStarts", "children", "appendTo", "fullWidth", "onCloseInProgress", "onCloseNotInProgress"]);
-    const { activeQuickStartID, setActiveQuickStart, allQuickStarts = [], allQuickStartStates, setAllQuickStartStates, } = React.useContext(QuickStartContext);
+    const { activeQuickStartID, setActiveQuickStart, allQuickStarts = [], allQuickStartStates, setAllQuickStartStates, } = useContext(QuickStartContext);
     const combinedQuickStarts = allQuickStarts.concat(quickStarts);
-    React.useEffect(() => {
+    useEffect(() => {
         const params = new URLSearchParams(window.location.search);
         // if there is a quick start param, but the quick start is not active, set it
         // this can happen if a new browser session is opened or an incognito window for example
@@ -29801,13 +31004,13 @@ const QuickStartDrawer = (_a) => {
             }
         }
     }, [activeQuickStartID, combinedQuickStarts, setActiveQuickStart]);
-    React.useEffect(() => {
+    useEffect(() => {
         // If activeQuickStartID was changed through prop from QuickStartContainer, need to init the state if it does not exist yet
         if (activeQuickStartID && !allQuickStartStates[activeQuickStartID]) {
             setAllQuickStartStates(Object.assign(Object.assign({}, allQuickStartStates), { [activeQuickStartID]: getDefaultQuickStartState() }));
         }
     }, [activeQuickStartID, allQuickStartStates, setAllQuickStartStates]);
-    const [modalOpen, setModalOpen] = React.useState(false);
+    const [modalOpen, setModalOpen] = useState(false);
     const onClose = () => setActiveQuickStart('');
     const handleClose = (activeQuickStartStatus) => {
         if (activeQuickStartStatus === QuickStartStatus.IN_PROGRESS) {
@@ -29837,11 +31040,7 @@ const QuickStartDrawer = (_a) => {
             },
         }
         : {};
-    return (React.createElement(React.Fragment, null,
-        React.createElement(Drawer, Object.assign({ isExpanded: !!activeQuickStartID, isInline: true }, props),
-            React.createElement(DrawerContent, Object.assign({ panelContent: React.createElement(QuickStartDrawerContent, { quickStarts: combinedQuickStarts, handleDrawerClose: handleClose, appendTo: appendTo, fullWidth: fullWidth }) }, fullWidthBodyStyle),
-                React.createElement(DrawerContentBody, null, children))),
-        React.createElement(QuickStartCloseModal, { isOpen: modalOpen, onConfirm: onModalConfirm, onCancel: onModalCancel })));
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(Drawer, Object.assign({ isExpanded: !!activeQuickStartID, isInline: true }, props, { children: jsxRuntime.jsx(DrawerContent, Object.assign({ panelContent: jsxRuntime.jsx(QuickStartDrawerContent, { quickStarts: combinedQuickStarts, handleDrawerClose: handleClose, appendTo: appendTo, fullWidth: fullWidth }) }, fullWidthBodyStyle, { children: jsxRuntime.jsx(DrawerContentBody, { children: children }) })) })), jsxRuntime.jsx(QuickStartCloseModal, { isOpen: modalOpen, onConfirm: onModalConfirm, onCancel: onModalCancel })] }));
 };
 
 const QuickStartContainer = (_a) => {
@@ -29856,13 +31055,13 @@ const QuickStartContainer = (_a) => {
         useQueryParams,
         markdown,
         alwaysShowTaskReview }, contextProps));
-    React.useEffect(() => {
+    useEffect(() => {
         if (quickStarts &&
             JSON.stringify(quickStarts) !== JSON.stringify(valuesForQuickstartContext.allQuickStarts)) {
             valuesForQuickstartContext.setAllQuickStarts(quickStarts);
         }
     }, [quickStarts, valuesForQuickstartContext]);
-    React.useEffect(() => {
+    useEffect(() => {
         if (loading !== valuesForQuickstartContext.loading) {
             valuesForQuickstartContext.setLoading(loading);
         }
@@ -29871,7 +31070,7 @@ const QuickStartContainer = (_a) => {
         fullWidth,
         onCloseInProgress,
         onCloseNotInProgress }, props);
-    return (React.createElement(QuickStartContext.Provider, { value: valuesForQuickstartContext }, isManagedDrawer ? (React.createElement(QuickStartDrawer, Object.assign({}, drawerProps), children)) : (children)));
+    return (jsxRuntime.jsx(QuickStartContext.Provider, Object.assign({ value: valuesForQuickstartContext }, { children: isManagedDrawer ? (jsxRuntime.jsx(QuickStartDrawer, Object.assign({}, drawerProps, { children: children }))) : (children) })));
 };
 
 var barsIcon = createCommonjsModule(function (module, exports) {
@@ -29899,14 +31098,14 @@ const HelpTopicContextDefaults = {
     setFilteredHelpTopics: () => { },
     loading: false,
 };
-const HelpTopicContext = React__default.createContext(HelpTopicContextDefaults);
+const HelpTopicContext = createContext(HelpTopicContextDefaults);
 const useValuesForHelpTopicContext = (value = {}) => {
     const combinedValue = Object.assign(Object.assign({}, HelpTopicContextDefaults), value);
-    const [loading, setLoading] = React__default.useState(combinedValue.loading);
+    const [loading, setLoading] = useState(combinedValue.loading);
     // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    const [helpTopics, setHelpTopics] = React__default.useState(combinedValue.helpTopics || []);
-    const [activeHelpTopic, setActiveHelpTopic] = React__default.useState(combinedValue.activeHelpTopic || null);
-    const setActiveHelpTopicByName = React__default.useCallback((helpTopicName) => {
+    const [helpTopics, setHelpTopics] = useState(combinedValue.helpTopics || []);
+    const [activeHelpTopic, setActiveHelpTopic] = useState(combinedValue.activeHelpTopic || null);
+    const setActiveHelpTopicByName = useCallback((helpTopicName) => {
         const topic = helpTopics.find((t) => t.name === helpTopicName);
         if (!helpTopicName) {
             setActiveHelpTopic(null);
@@ -29914,7 +31113,7 @@ const useValuesForHelpTopicContext = (value = {}) => {
         }
         setActiveHelpTopic(topic);
     }, [helpTopics]);
-    const [filteredHelpTopics, setFilteredHelpTopics] = React__default.useState(combinedValue.filteredHelpTopics || []);
+    const [filteredHelpTopics, setFilteredHelpTopics] = useState(combinedValue.filteredHelpTopics || []);
     return {
         helpTopics,
         setHelpTopics,
@@ -29930,8 +31129,8 @@ const useValuesForHelpTopicContext = (value = {}) => {
 const HelpTopicPanelContent = (_a) => {
     var _b, _c;
     var { activeHelpTopic = null, filteredHelpTopics = [], isResizable = true, onClose } = _a, props = __rest(_a, ["activeHelpTopic", "filteredHelpTopics", "isResizable", "onClose"]);
-    const { setActiveHelpTopicByName } = React.useContext(HelpTopicContext);
-    const [isHelpTopicMenuOpen, setIsHelpTopicMenuOpen] = React.useState(false);
+    const { setActiveHelpTopicByName } = useContext(HelpTopicContext);
+    const [isHelpTopicMenuOpen, setIsHelpTopicMenuOpen] = useState(false);
     const toggleHelpTopicMenu = () => {
         setIsHelpTopicMenuOpen(!isHelpTopicMenuOpen);
     };
@@ -29941,24 +31140,10 @@ const HelpTopicPanelContent = (_a) => {
         toggleHelpTopicMenu();
     };
     const helpTopicOptions = filteredHelpTopics.length > 1 &&
-        filteredHelpTopics.map((topic) => (React.createElement(SelectOption, { key: topic.name, value: topic.name }, topic.title)));
-    const paddingContainer = (children) => React.createElement("div", { style: { padding: '24px' } }, children);
-    const panelBodyItems = (React.createElement(React.Fragment, null,
-        paddingContainer(React.createElement(QuickStartMarkdownView, { content: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.content })),
-        !!((_b = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _b === void 0 ? void 0 : _b.length) && React.createElement(Divider, null),
-        paddingContainer(React.createElement(Stack, { hasGutter: true }, (_c = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _c === void 0 ? void 0 : _c.map(({ href, text, newTab, isExternal }, index) => (React.createElement(StackItem, { key: index },
-            React.createElement(Button, { component: "a", href: href, target: newTab ? '_blank' : '', rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: isExternal ? React.createElement(ExternalLinkAltIcon, null) : null, iconPosition: "right", style: { fontSize: 'inherit' } }, text || href))))))));
-    const content = (React.createElement(DrawerPanelContent, Object.assign({ isResizable: isResizable }, props),
-        React.createElement("div", null,
-            React.createElement(DrawerHead, null,
-                React.createElement("div", null,
-                    helpTopicOptions && (React.createElement(Select, { isPlain: true, id: "help-topics-select", selected: activeHelpTopic, isOpen: isHelpTopicMenuOpen, onSelect: onSelectHelpTopic, onOpenChange: (isOpen) => setIsHelpTopicMenuOpen(isOpen), toggle: (toggleRef) => (React.createElement(MenuToggle, { isFullWidth: true, ref: toggleRef, icon: React.createElement(BarsIcon, null), onClick: toggleHelpTopicMenu, isExpanded: isHelpTopicMenuOpen }, activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title)) },
-                        React.createElement(SelectList, null, helpTopicOptions))),
-                    React.createElement(Title, { headingLevel: "h1", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title)),
-                React.createElement(DrawerActions, null,
-                    React.createElement(DrawerCloseButton, { onClick: onClose, "data-testid": "qs-drawer-close" }))),
-            React.createElement(Divider, null),
-            React.createElement(DrawerPanelBody, { "data-test": "content" }, panelBodyItems))));
+        filteredHelpTopics.map((topic) => (jsxRuntime.jsx(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(Divider, {}), paddingContainer(jsxRuntime.jsx(Stack, Object.assign({ hasGutter: true }, { children: (_c = activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.links) === null || _c === void 0 ? void 0 : _c.map(({ href, text, newTab, isExternal }, index) => (jsxRuntime.jsx(StackItem, { children: jsxRuntime.jsx(Button, Object.assign({ component: "a", href: href, target: newTab ? '_blank' : '', rel: "noopener noreferrer", variant: "link", "aria-label": `Open documentation in new window`, isInline: true, icon: isExternal ? jsxRuntime.jsx(ExternalLinkAltIcon, {}) : null, iconPosition: "right", style: { fontSize: 'inherit' } }, { children: text || href })) }, index))) })))] }));
+    const content = (jsxRuntime.jsx(DrawerPanelContent, Object.assign({ isResizable: isResizable }, props, { children: jsxRuntime.jsxs("div", { children: [jsxRuntime.jsxs(DrawerHead, { children: [jsxRuntime.jsxs("div", { children: [helpTopicOptions && (jsxRuntime.jsx(Select, Object.assign({ isPlain: true, id: "help-topics-select", selected: activeHelpTopic, isOpen: isHelpTopicMenuOpen, onSelect: onSelectHelpTopic, onOpenChange: (isOpen) => setIsHelpTopicMenuOpen(isOpen), toggle: (toggleRef) => (jsxRuntime.jsx(MenuToggle, Object.assign({ isFullWidth: true, ref: toggleRef, icon: jsxRuntime.jsx(BarsIcon, {}), onClick: toggleHelpTopicMenu, isExpanded: isHelpTopicMenuOpen }, { children: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title }))) }, { children: jsxRuntime.jsx(SelectList, { children: helpTopicOptions }) }))), jsxRuntime.jsx(Title, Object.assign({ headingLevel: "h1", size: "xl", style: { marginRight: 'var(--pf-t--global--spacer--md)' } }, { children: activeHelpTopic === null || activeHelpTopic === void 0 ? void 0 : activeHelpTopic.title }))] }), jsxRuntime.jsx(DrawerActions, { children: jsxRuntime.jsx(DrawerCloseButton, { onClick: onClose, "data-testid": "qs-drawer-close" }) })] }), jsxRuntime.jsx(Divider, {}), jsxRuntime.jsx(DrawerPanelBody, Object.assign({ "data-test": "content" }, { children: panelBodyItems }))] }) })));
     return content;
 };
 
@@ -29967,30 +31152,27 @@ const HelpTopicContainer = (_a) => {
     const valuesForHelpTopicContext = useValuesForHelpTopicContext(Object.assign({ helpTopics,
         language, resourceBundle: Object.assign({}, resourceBundle), loading,
         markdown }, contextProps));
-    React.useEffect(() => {
+    useEffect(() => {
         if (loading !== valuesForHelpTopicContext.loading) {
             valuesForHelpTopicContext.setLoading(loading);
         }
     }, [loading, valuesForHelpTopicContext]);
-    React.useEffect(() => {
+    useEffect(() => {
         if (helpTopics &&
             JSON.stringify(helpTopics) !== JSON.stringify(valuesForHelpTopicContext.helpTopics)) {
             valuesForHelpTopicContext.setHelpTopics(helpTopics);
         }
     }, [helpTopics, valuesForHelpTopicContext]);
-    return (React.createElement(HelpTopicContext.Provider, { value: valuesForHelpTopicContext },
-        React.createElement(HelpTopicDrawer, Object.assign({}, props), children)));
+    return (jsxRuntime.jsx(HelpTopicContext.Provider, Object.assign({ value: valuesForHelpTopicContext }, { children: jsxRuntime.jsx(HelpTopicDrawer, Object.assign({}, props, { children: children })) })));
 };
 const HelpTopicDrawer = (_a) => {
     var { children } = _a, props = __rest(_a, ["children"]);
-    const { activeHelpTopic, filteredHelpTopics, setActiveHelpTopicByName } = React.useContext(HelpTopicContext);
+    const { activeHelpTopic, filteredHelpTopics, setActiveHelpTopicByName } = useContext(HelpTopicContext);
     const onClose = () => {
         setActiveHelpTopicByName('');
     };
-    const panelContent = (React.createElement(HelpTopicPanelContent, { activeHelpTopic: activeHelpTopic, filteredHelpTopics: filteredHelpTopics, onClose: onClose }));
-    return (React.createElement(React.Fragment, null,
-        React.createElement(Drawer, Object.assign({ isExpanded: !!activeHelpTopic, isInline: true }, props), children ? (React.createElement(DrawerContent, { panelContent: panelContent },
-            React.createElement(DrawerContentBody, null, children))) : (React.createElement("div", { className: "pf-v6-c-drawer__main" }, panelContent)))));
+    const panelContent = (jsxRuntime.jsx(HelpTopicPanelContent, { activeHelpTopic: activeHelpTopic, filteredHelpTopics: filteredHelpTopics, onClose: onClose }));
+    return (jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxRuntime.jsx(Drawer, Object.assign({ isExpanded: !!activeHelpTopic, isInline: true }, props, { children: children ? (jsxRuntime.jsx(DrawerContent, Object.assign({ panelContent: panelContent }, { children: jsxRuntime.jsx(DrawerContentBody, { children: children }) }))) : (jsxRuntime.jsx("div", Object.assign({ className: "pf-v6-c-drawer__main" }, { children: panelContent }))) })) }));
 };
 
 const useLocalStorage = (key, initialValue) => {