wip:milestone 0 fixes

control-plane-ui/README.md

@@ -0,0 +1,117 @@
+# MadBase Control Plane UI
+
+Web-based administration interface for the MadBase Control Plane.
+
+## Features
+
+- 📊 **Dashboard** - Overview of cluster health and metrics
+- 🖥️ **Server Management** - Add, remove, and monitor servers
+- 📋 **Templates** - Deploy pre-configured server templates
+- ☁️ **Providers** - View VPS provider options and pricing
+- 📈 **Scaling** - Visual scaling tool with cost estimation
+- 💚 **Cluster Health** - Real-time cluster monitoring
+- ⚙️ **Settings** - Configure API endpoints and credentials
+
+## Quick Start
+
+```bash
+# Install dependencies
+npm install
+
+# Run development server
+npm run dev
+
+# Build for production
+npm run build
+
+# Preview production build
+npm run preview
+```
+
+The UI will be available at `http://localhost:3000`
+
+## Tech Stack
+
+- **React 18** - UI framework
+- **TypeScript** - Type safety
+- **Material-UI** - Component library
+- **TanStack Query** - Data fetching and caching
+- **React Router** - Routing
+- **Vite** - Build tool
+
+## Pages
+
+### Dashboard
+- Cluster overview
+- Server count and status
+- Quick actions
+- Recent activity
+
+### Servers
+- List all servers
+- Add new servers
+- Remove servers (with data integrity checks)
+- View server status
+
+### Templates
+- View all available templates
+- See template details (cost, services, requirements)
+- Deploy from templates
+
+### Providers
+- View supported VPS providers
+- See available plans and pricing
+- Compare provider options
+
+### Scaling
+- Configure scaling parameters
+- View cost estimates
+- Execute scaling plans
+
+### Cluster Health
+- Real-time cluster status
+- Server metrics
+- Service health
+
+## Configuration
+
+The UI connects to the Control Plane API at `http://localhost:8001` by default. To change this:
+
+`vite.config.ts`:
+``typescript
+server: {
+  proxy: {
+    '/api': {
+      target: 'http://your-api-url:8001',
+      changeOrigin: true,
+    },
+  },
+}
+```
+
+## Building for Production
+
+```bash
+npm run build
+```
+
+The built files will be in `dist/`. Serve them with any static file server:
+
+```bash
+npx serve dist
+```
+
+## Deployment
+
+The UI can be served from:
+- The Control Plane proxy (port 8080)
+- Nginx/Apache
+- CDN (CloudFlare, Netlify, Vercel)
+
+## Environment Variables
+
+No environment variables required for development. For production:
+
+``ash
+VITE_API_URL=http://your-api-url:8001
+```

control-plane-ui/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>MadBase Control Plane</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

control-plane-ui/node_modules/.bin/acorn

@@ -0,0 +1 @@
+../acorn/bin/acorn

control-plane-ui/node_modules/.bin/baseline-browser-mapping

@@ -0,0 +1 @@
+../baseline-browser-mapping/dist/cli.cjs

control-plane-ui/node_modules/.bin/browserslist

@@ -0,0 +1 @@
+../browserslist/cli.js

control-plane-ui/node_modules/.bin/esbuild

@@ -0,0 +1 @@
+../esbuild/bin/esbuild

control-plane-ui/node_modules/.bin/eslint

@@ -0,0 +1 @@
+../eslint/bin/eslint.js

control-plane-ui/node_modules/.bin/js-yaml

@@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js

control-plane-ui/node_modules/.bin/jsesc

@@ -0,0 +1 @@
+../jsesc/bin/jsesc

control-plane-ui/node_modules/.bin/json5

@@ -0,0 +1 @@
+../json5/lib/cli.js

control-plane-ui/node_modules/.bin/loose-envify

@@ -0,0 +1 @@
+../loose-envify/cli.js

control-plane-ui/node_modules/.bin/lz-string

@@ -0,0 +1 @@
+../lz-string/bin/bin.js

control-plane-ui/node_modules/.bin/msw

@@ -0,0 +1 @@
+../msw/cli/index.js

control-plane-ui/node_modules/.bin/nanoid

@@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs

control-plane-ui/node_modules/.bin/node-which

@@ -0,0 +1 @@
+../which/bin/node-which

control-plane-ui/node_modules/.bin/parser

@@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js

control-plane-ui/node_modules/.bin/playwright

@@ -0,0 +1 @@
+../@playwright/test/cli.js

control-plane-ui/node_modules/.bin/playwright-core

@@ -0,0 +1 @@
+../playwright-core/cli.js

control-plane-ui/node_modules/.bin/resolve

@@ -0,0 +1 @@
+../resolve/bin/resolve

control-plane-ui/node_modules/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/bin.js

control-plane-ui/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../rollup/dist/bin/rollup

control-plane-ui/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

control-plane-ui/node_modules/.bin/tldts

@@ -0,0 +1 @@
+../tldts/bin/cli.js

control-plane-ui/node_modules/.bin/tsc

@@ -0,0 +1 @@
+../typescript/bin/tsc

control-plane-ui/node_modules/.bin/tsserver

@@ -0,0 +1 @@
+../typescript/bin/tsserver

control-plane-ui/node_modules/.bin/update-browserslist-db

@@ -0,0 +1 @@
+../update-browserslist-db/cli.js

control-plane-ui/node_modules/.bin/vite

@@ -0,0 +1 @@
+../vite/bin/vite.js

control-plane-ui/node_modules/.bin/vite-node

@@ -0,0 +1 @@
+../vite-node/vite-node.mjs

control-plane-ui/node_modules/.bin/vitest

@@ -0,0 +1 @@
+../vitest/vitest.mjs

control-plane-ui/node_modules/.bin/why-is-node-running

@@ -0,0 +1 @@
+../why-is-node-running/cli.js

control-plane-ui/node_modules/.vite/deps/@mui_material_CssBaseline.js

@@ -0,0 +1,15 @@
+"use client";
+import {
+  CssBaseline_default
+} from "./chunk-WHT54KGP.js";
+import "./chunk-WDD75YPL.js";
+import "./chunk-ZHUI7O2A.js";
+import "./chunk-4B2NWW42.js";
+import "./chunk-QLKRFDUE.js";
+import "./chunk-WKPQ4ZTV.js";
+import "./chunk-BG45W2ER.js";
+import "./chunk-HXA6O6EE.js";
+export {
+  CssBaseline_default as default
+};
+//# sourceMappingURL=@mui_material_CssBaseline.js.map

control-plane-ui/node_modules/.vite/deps/@mui_material_CssBaseline.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

control-plane-ui/node_modules/.vite/deps/@mui_material_styles.js

@@ -0,0 +1,100 @@
+"use client";
+import {
+  CssVarsProvider,
+  ThemeProvider,
+  adaptV4Theme,
+  createMuiStrictModeTheme,
+  createStyles,
+  excludeVariablesFromRoot_default,
+  experimental_sx,
+  extendTheme,
+  getInitColorSchemeScript,
+  getOverlayAlpha_default,
+  getUnit,
+  makeStyles,
+  responsiveFontSizes,
+  shouldSkipGeneratingVar,
+  toUnitless,
+  useColorScheme,
+  useTheme,
+  useThemeProps,
+  withStyles,
+  withTheme
+} from "./chunk-Y5IG6O7D.js";
+import {
+  alpha,
+  darken,
+  decomposeColor,
+  emphasize,
+  getContrastRatio,
+  getLuminance,
+  hexToRgb,
+  hslToRgb,
+  lighten,
+  recomposeColor,
+  rgbToHex
+} from "./chunk-ZHUI7O2A.js";
+import {
+  styled_default
+} from "./chunk-JWRIH3ST.js";
+import {
+  StyledEngineProvider,
+  createMixins,
+  createMuiTheme,
+  createTheme_default2 as createTheme_default,
+  createTypography,
+  css,
+  duration,
+  easing,
+  identifier_default,
+  keyframes
+} from "./chunk-QLKRFDUE.js";
+import "./chunk-WKPQ4ZTV.js";
+import "./chunk-BG45W2ER.js";
+import "./chunk-HXA6O6EE.js";
+export {
+  CssVarsProvider as Experimental_CssVarsProvider,
+  StyledEngineProvider,
+  identifier_default as THEME_ID,
+  ThemeProvider,
+  adaptV4Theme,
+  alpha,
+  createMuiTheme,
+  createStyles,
+  createTheme_default as createTheme,
+  css,
+  darken,
+  decomposeColor,
+  duration,
+  easing,
+  emphasize,
+  styled_default as experimentalStyled,
+  extendTheme as experimental_extendTheme,
+  experimental_sx,
+  getContrastRatio,
+  getInitColorSchemeScript,
+  getLuminance,
+  getOverlayAlpha_default as getOverlayAlpha,
+  hexToRgb,
+  hslToRgb,
+  keyframes,
+  lighten,
+  makeStyles,
+  createMixins as private_createMixins,
+  createTypography as private_createTypography,
+  excludeVariablesFromRoot_default as private_excludeVariablesFromRoot,
+  recomposeColor,
+  responsiveFontSizes,
+  rgbToHex,
+  shouldSkipGeneratingVar,
+  styled_default as styled,
+  createMuiStrictModeTheme as unstable_createMuiStrictModeTheme,
+  getUnit as unstable_getUnit,
+  toUnitless as unstable_toUnitless,
+  useColorScheme,
+  useTheme,
+  useThemeProps,
+  withStyles,
+  withTheme
+};
+//# sourceMappingURL=@mui_material_styles.js.map

control-plane-ui/node_modules/.vite/deps/@mui_material_styles.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

control-plane-ui/node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,127 @@
+{
+  "hash": "68f50e1b",
+  "configHash": "6c753f2f",
+  "lockfileHash": "de0c6e40",
+  "browserHash": "95ed1528",
+  "optimized": {
+    "react": {
+      "src": "../../react/index.js",
+      "file": "react.js",
+      "fileHash": "677b95db",
+      "needsInterop": true
+    },
+    "react-dom": {
+      "src": "../../react-dom/index.js",
+      "file": "react-dom.js",
+      "fileHash": "f28ceebf",
+      "needsInterop": true
+    },
+    "react/jsx-dev-runtime": {
+      "src": "../../react/jsx-dev-runtime.js",
+      "file": "react_jsx-dev-runtime.js",
+      "fileHash": "0059f84e",
+      "needsInterop": true
+    },
+    "react/jsx-runtime": {
+      "src": "../../react/jsx-runtime.js",
+      "file": "react_jsx-runtime.js",
+      "fileHash": "35df02fb",
+      "needsInterop": true
+    },
+    "@mui/icons-material": {
+      "src": "../../@mui/icons-material/esm/index.js",
+      "file": "@mui_icons-material.js",
+      "fileHash": "85e768eb",
+      "needsInterop": false
+    },
+    "@mui/material": {
+      "src": "../../@mui/material/index.js",
+      "file": "@mui_material.js",
+      "fileHash": "dc63b1a7",
+      "needsInterop": false
+    },
+    "@mui/material/CssBaseline": {
+      "src": "../../@mui/material/CssBaseline/index.js",
+      "file": "@mui_material_CssBaseline.js",
+      "fileHash": "33859479",
+      "needsInterop": false
+    },
+    "@mui/material/styles": {
+      "src": "../../@mui/material/styles/index.js",
+      "file": "@mui_material_styles.js",
+      "fileHash": "715359dc",
+      "needsInterop": false
+    },
+    "@mui/x-data-grid": {
+      "src": "../../@mui/x-data-grid/index.js",
+      "file": "@mui_x-data-grid.js",
+      "fileHash": "fe6281ed",
+      "needsInterop": false
+    },
+    "@tanstack/react-query": {
+      "src": "../../@tanstack/react-query/build/modern/index.js",
+      "file": "@tanstack_react-query.js",
+      "fileHash": "ab03f426",
+      "needsInterop": false
+    },
+    "axios": {
+      "src": "../../axios/index.js",
+      "file": "axios.js",
+      "fileHash": "dad9ddbd",
+      "needsInterop": false
+    },
+    "react-dom/client": {
+      "src": "../../react-dom/client.js",
+      "file": "react-dom_client.js",
+      "fileHash": "23abbb63",
+      "needsInterop": true
+    },
+    "react-router-dom": {
+      "src": "../../react-router-dom/dist/index.js",
+      "file": "react-router-dom.js",
+      "fileHash": "a23e86d4",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-WHT54KGP": {
+      "file": "chunk-WHT54KGP.js"
+    },
+    "chunk-JXKN7L4A": {
+      "file": "chunk-JXKN7L4A.js"
+    },
+    "chunk-WDD75YPL": {
+      "file": "chunk-WDD75YPL.js"
+    },
+    "chunk-Y5IG6O7D": {
+      "file": "chunk-Y5IG6O7D.js"
+    },
+    "chunk-ZHUI7O2A": {
+      "file": "chunk-ZHUI7O2A.js"
+    },
+    "chunk-ANTY7EHM": {
+      "file": "chunk-ANTY7EHM.js"
+    },
+    "chunk-4B2NWW42": {
+      "file": "chunk-4B2NWW42.js"
+    },
+    "chunk-JWRIH3ST": {
+      "file": "chunk-JWRIH3ST.js"
+    },
+    "chunk-QLKRFDUE": {
+      "file": "chunk-QLKRFDUE.js"
+    },
+    "chunk-UPELNCPK": {
+      "file": "chunk-UPELNCPK.js"
+    },
+    "chunk-WKPQ4ZTV": {
+      "file": "chunk-WKPQ4ZTV.js"
+    },
+    "chunk-BG45W2ER": {
+      "file": "chunk-BG45W2ER.js"
+    },
+    "chunk-HXA6O6EE": {
+      "file": "chunk-HXA6O6EE.js"
+    }
+  }
+}

control-plane-ui/node_modules/.vite/deps/chunk-4B2NWW42.js

@@ -0,0 +1,47 @@
+import {
+  DefaultPropsProvider_default,
+  _extends,
+  init_extends,
+  require_prop_types,
+  useDefaultProps
+} from "./chunk-QLKRFDUE.js";
+import {
+  require_jsx_runtime
+} from "./chunk-WKPQ4ZTV.js";
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __toESM
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/@mui/material/DefaultPropsProvider/DefaultPropsProvider.js
+init_extends();
+var React = __toESM(require_react());
+var import_prop_types = __toESM(require_prop_types());
+var import_jsx_runtime = __toESM(require_jsx_runtime());
+function DefaultPropsProvider(props) {
+  return (0, import_jsx_runtime.jsx)(DefaultPropsProvider_default, _extends({}, props));
+}
+true ? DefaultPropsProvider.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: import_prop_types.default.node,
+  /**
+   * @ignore
+   */
+  value: import_prop_types.default.object.isRequired
+} : void 0;
+function useDefaultProps2(params) {
+  return useDefaultProps(params);
+}
+
+export {
+  useDefaultProps2 as useDefaultProps
+};
+//# sourceMappingURL=chunk-4B2NWW42.js.map

control-plane-ui/node_modules/.vite/deps/chunk-4B2NWW42.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../@mui/material/DefaultPropsProvider/DefaultPropsProvider.js"],
+  "sourcesContent": ["'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport SystemDefaultPropsProvider, { useDefaultProps as useSystemDefaultProps } from '@mui/system/DefaultPropsProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction DefaultPropsProvider(props) {\n  return /*#__PURE__*/_jsx(SystemDefaultPropsProvider, _extends({}, props));\n}\nprocess.env.NODE_ENV !== \"production\" ? DefaultPropsProvider.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * @ignore\n   */\n  children: PropTypes.node,\n  /**\n   * @ignore\n   */\n  value: PropTypes.object.isRequired\n} : void 0;\nexport default DefaultPropsProvider;\nexport function useDefaultProps(params) {\n  return useSystemDefaultProps(params);\n}"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAEA;AACA,YAAuB;AACvB,wBAAsB;AAEtB,yBAA4B;AAC5B,SAAS,qBAAqB,OAAO;AACnC,aAAoB,mBAAAA,KAAK,8BAA4B,SAAS,CAAC,GAAG,KAAK,CAAC;AAC1E;AACA,OAAwC,qBAAqB,YAAmC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9F,UAAU,kBAAAC,QAAU;AAAA;AAAA;AAAA;AAAA,EAIpB,OAAO,kBAAAA,QAAU,OAAO;AAC1B,IAAI;AAEG,SAASC,iBAAgB,QAAQ;AACtC,SAAO,gBAAsB,MAAM;AACrC;",
+  "names": ["_jsx", "PropTypes", "useDefaultProps"]
+}

control-plane-ui/node_modules/.vite/deps/chunk-ANTY7EHM.js

@@ -0,0 +1,333 @@
+import {
+  useDefaultProps
+} from "./chunk-4B2NWW42.js";
+import {
+  styled_default
+} from "./chunk-JWRIH3ST.js";
+import {
+  ClassNameGenerator_default,
+  _extends,
+  _objectWithoutPropertiesLoose,
+  capitalize,
+  clsx_default,
+  composeClasses,
+  createChainedFunction,
+  debounce,
+  deprecatedPropType,
+  generateUtilityClass,
+  generateUtilityClasses,
+  init_capitalize,
+  init_extends,
+  isMuiElement,
+  ownerDocument,
+  ownerWindow,
+  requirePropFactory,
+  require_prop_types,
+  setRef,
+  unsupportedProp,
+  useControlled,
+  useEnhancedEffect_default,
+  useEventCallback_default,
+  useForkRef,
+  useId,
+  useIsFocusVisible
+} from "./chunk-QLKRFDUE.js";
+import {
+  require_jsx_runtime
+} from "./chunk-WKPQ4ZTV.js";
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __toESM
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/@mui/material/utils/capitalize.js
+init_capitalize();
+var capitalize_default = capitalize;
+
+// node_modules/@mui/material/utils/createChainedFunction.js
+var createChainedFunction_default = createChainedFunction;
+
+// node_modules/@mui/material/SvgIcon/svgIconClasses.js
+function getSvgIconUtilityClass(slot) {
+  return generateUtilityClass("MuiSvgIcon", slot);
+}
+var svgIconClasses = generateUtilityClasses("MuiSvgIcon", ["root", "colorPrimary", "colorSecondary", "colorAction", "colorError", "colorDisabled", "fontSizeInherit", "fontSizeSmall", "fontSizeMedium", "fontSizeLarge"]);
+var svgIconClasses_default = svgIconClasses;
+
+// node_modules/@mui/material/SvgIcon/SvgIcon.js
+init_extends();
+var React = __toESM(require_react());
+var import_prop_types = __toESM(require_prop_types());
+var import_jsx_runtime = __toESM(require_jsx_runtime());
+var import_jsx_runtime2 = __toESM(require_jsx_runtime());
+var _excluded = ["children", "className", "color", "component", "fontSize", "htmlColor", "inheritViewBox", "titleAccess", "viewBox"];
+var useUtilityClasses = (ownerState) => {
+  const {
+    color,
+    fontSize,
+    classes
+  } = ownerState;
+  const slots = {
+    root: ["root", color !== "inherit" && `color${capitalize_default(color)}`, `fontSize${capitalize_default(fontSize)}`]
+  };
+  return composeClasses(slots, getSvgIconUtilityClass, classes);
+};
+var SvgIconRoot = styled_default("svg", {
+  name: "MuiSvgIcon",
+  slot: "Root",
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, ownerState.color !== "inherit" && styles[`color${capitalize_default(ownerState.color)}`], styles[`fontSize${capitalize_default(ownerState.fontSize)}`]];
+  }
+})(({
+  theme,
+  ownerState
+}) => {
+  var _theme$transitions, _theme$transitions$cr, _theme$transitions2, _theme$typography, _theme$typography$pxT, _theme$typography2, _theme$typography2$px, _theme$typography3, _theme$typography3$px, _palette$ownerState$c, _palette, _palette2, _palette3;
+  return {
+    userSelect: "none",
+    width: "1em",
+    height: "1em",
+    display: "inline-block",
+    // the <svg> will define the property that has `currentColor`
+    // for example heroicons uses fill="none" and stroke="currentColor"
+    fill: ownerState.hasSvgAsChild ? void 0 : "currentColor",
+    flexShrink: 0,
+    transition: (_theme$transitions = theme.transitions) == null || (_theme$transitions$cr = _theme$transitions.create) == null ? void 0 : _theme$transitions$cr.call(_theme$transitions, "fill", {
+      duration: (_theme$transitions2 = theme.transitions) == null || (_theme$transitions2 = _theme$transitions2.duration) == null ? void 0 : _theme$transitions2.shorter
+    }),
+    fontSize: {
+      inherit: "inherit",
+      small: ((_theme$typography = theme.typography) == null || (_theme$typography$pxT = _theme$typography.pxToRem) == null ? void 0 : _theme$typography$pxT.call(_theme$typography, 20)) || "1.25rem",
+      medium: ((_theme$typography2 = theme.typography) == null || (_theme$typography2$px = _theme$typography2.pxToRem) == null ? void 0 : _theme$typography2$px.call(_theme$typography2, 24)) || "1.5rem",
+      large: ((_theme$typography3 = theme.typography) == null || (_theme$typography3$px = _theme$typography3.pxToRem) == null ? void 0 : _theme$typography3$px.call(_theme$typography3, 35)) || "2.1875rem"
+    }[ownerState.fontSize],
+    // TODO v5 deprecate, v6 remove for sx
+    color: (_palette$ownerState$c = (_palette = (theme.vars || theme).palette) == null || (_palette = _palette[ownerState.color]) == null ? void 0 : _palette.main) != null ? _palette$ownerState$c : {
+      action: (_palette2 = (theme.vars || theme).palette) == null || (_palette2 = _palette2.action) == null ? void 0 : _palette2.active,
+      disabled: (_palette3 = (theme.vars || theme).palette) == null || (_palette3 = _palette3.action) == null ? void 0 : _palette3.disabled,
+      inherit: void 0
+    }[ownerState.color]
+  };
+});
+var SvgIcon = React.forwardRef(function SvgIcon2(inProps, ref) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: "MuiSvgIcon"
+  });
+  const {
+    children,
+    className,
+    color = "inherit",
+    component = "svg",
+    fontSize = "medium",
+    htmlColor,
+    inheritViewBox = false,
+    titleAccess,
+    viewBox = "0 0 24 24"
+  } = props, other = _objectWithoutPropertiesLoose(props, _excluded);
+  const hasSvgAsChild = React.isValidElement(children) && children.type === "svg";
+  const ownerState = _extends({}, props, {
+    color,
+    component,
+    fontSize,
+    instanceFontSize: inProps.fontSize,
+    inheritViewBox,
+    viewBox,
+    hasSvgAsChild
+  });
+  const more = {};
+  if (!inheritViewBox) {
+    more.viewBox = viewBox;
+  }
+  const classes = useUtilityClasses(ownerState);
+  return (0, import_jsx_runtime2.jsxs)(SvgIconRoot, _extends({
+    as: component,
+    className: clsx_default(classes.root, className),
+    focusable: "false",
+    color: htmlColor,
+    "aria-hidden": titleAccess ? void 0 : true,
+    role: titleAccess ? "img" : void 0,
+    ref
+  }, more, other, hasSvgAsChild && children.props, {
+    ownerState,
+    children: [hasSvgAsChild ? children.props.children : children, titleAccess ? (0, import_jsx_runtime.jsx)("title", {
+      children: titleAccess
+    }) : null]
+  }));
+});
+true ? SvgIcon.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Node passed into the SVG element.
+   */
+  children: import_prop_types.default.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: import_prop_types.default.object,
+  /**
+   * @ignore
+   */
+  className: import_prop_types.default.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * You can use the `htmlColor` prop to apply a color attribute to the SVG element.
+   * @default 'inherit'
+   */
+  color: import_prop_types.default.oneOfType([import_prop_types.default.oneOf(["inherit", "action", "disabled", "primary", "secondary", "error", "info", "success", "warning"]), import_prop_types.default.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: import_prop_types.default.elementType,
+  /**
+   * The fontSize applied to the icon. Defaults to 24px, but can be configure to inherit font size.
+   * @default 'medium'
+   */
+  fontSize: import_prop_types.default.oneOfType([import_prop_types.default.oneOf(["inherit", "large", "medium", "small"]), import_prop_types.default.string]),
+  /**
+   * Applies a color attribute to the SVG element.
+   */
+  htmlColor: import_prop_types.default.string,
+  /**
+   * If `true`, the root node will inherit the custom `component`'s viewBox and the `viewBox`
+   * prop will be ignored.
+   * Useful when you want to reference a custom `component` and have `SvgIcon` pass that
+   * `component`'s viewBox to the root node.
+   * @default false
+   */
+  inheritViewBox: import_prop_types.default.bool,
+  /**
+   * The shape-rendering attribute. The behavior of the different options is described on the
+   * [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/shape-rendering).
+   * If you are having issues with blurry icons you should investigate this prop.
+   */
+  shapeRendering: import_prop_types.default.string,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: import_prop_types.default.oneOfType([import_prop_types.default.arrayOf(import_prop_types.default.oneOfType([import_prop_types.default.func, import_prop_types.default.object, import_prop_types.default.bool])), import_prop_types.default.func, import_prop_types.default.object]),
+  /**
+   * Provides a human-readable title for the element that contains it.
+   * https://www.w3.org/TR/SVG-access/#Equivalent
+   */
+  titleAccess: import_prop_types.default.string,
+  /**
+   * Allows you to redefine what the coordinates without units mean inside an SVG element.
+   * For example, if the SVG element is 500 (width) by 200 (height),
+   * and you pass viewBox="0 0 50 20",
+   * this means that the coordinates inside the SVG will go from the top left corner (0,0)
+   * to bottom right (50,20) and each unit will be worth 10px.
+   * @default '0 0 24 24'
+   */
+  viewBox: import_prop_types.default.string
+} : void 0;
+SvgIcon.muiName = "SvgIcon";
+var SvgIcon_default = SvgIcon;
+
+// node_modules/@mui/material/utils/createSvgIcon.js
+init_extends();
+var React2 = __toESM(require_react());
+var import_jsx_runtime3 = __toESM(require_jsx_runtime());
+function createSvgIcon(path, displayName) {
+  function Component(props, ref) {
+    return (0, import_jsx_runtime3.jsx)(SvgIcon_default, _extends({
+      "data-testid": `${displayName}Icon`,
+      ref
+    }, props, {
+      children: path
+    }));
+  }
+  if (true) {
+    Component.displayName = `${displayName}Icon`;
+  }
+  Component.muiName = SvgIcon_default.muiName;
+  return React2.memo(React2.forwardRef(Component));
+}
+
+// node_modules/@mui/material/utils/debounce.js
+var debounce_default = debounce;
+
+// node_modules/@mui/material/utils/deprecatedPropType.js
+var deprecatedPropType_default = deprecatedPropType;
+
+// node_modules/@mui/material/utils/isMuiElement.js
+var isMuiElement_default = isMuiElement;
+
+// node_modules/@mui/material/utils/ownerDocument.js
+var ownerDocument_default = ownerDocument;
+
+// node_modules/@mui/material/utils/ownerWindow.js
+var ownerWindow_default = ownerWindow;
+
+// node_modules/@mui/material/utils/requirePropFactory.js
+var requirePropFactory_default = requirePropFactory;
+
+// node_modules/@mui/material/utils/setRef.js
+var setRef_default = setRef;
+
+// node_modules/@mui/material/utils/useEnhancedEffect.js
+var useEnhancedEffect_default2 = useEnhancedEffect_default;
+
+// node_modules/@mui/material/utils/useId.js
+var useId_default = useId;
+
+// node_modules/@mui/material/utils/unsupportedProp.js
+var unsupportedProp_default = unsupportedProp;
+
+// node_modules/@mui/material/utils/useControlled.js
+var useControlled_default = useControlled;
+
+// node_modules/@mui/material/utils/useEventCallback.js
+var useEventCallback_default2 = useEventCallback_default;
+
+// node_modules/@mui/material/utils/useForkRef.js
+var useForkRef_default = useForkRef;
+
+// node_modules/@mui/material/utils/useIsFocusVisible.js
+var useIsFocusVisible_default = useIsFocusVisible;
+
+// node_modules/@mui/material/utils/index.js
+var unstable_ClassNameGenerator = {
+  configure: (generator) => {
+    if (true) {
+      console.warn(["MUI: `ClassNameGenerator` import from `@mui/material/utils` is outdated and might cause unexpected issues.", "", "You should use `import { unstable_ClassNameGenerator } from '@mui/material/className'` instead", "", "The detail of the issue: https://github.com/mui/material-ui/issues/30011#issuecomment-1024993401", "", "The updated documentation: https://mui.com/guides/classname-generator/"].join("\n"));
+    }
+    ClassNameGenerator_default.configure(generator);
+  }
+};
+
+export {
+  capitalize_default,
+  createChainedFunction_default,
+  getSvgIconUtilityClass,
+  svgIconClasses_default,
+  SvgIcon_default,
+  createSvgIcon,
+  debounce_default,
+  deprecatedPropType_default,
+  isMuiElement_default,
+  ownerDocument_default,
+  ownerWindow_default,
+  requirePropFactory_default,
+  setRef_default,
+  useEnhancedEffect_default2 as useEnhancedEffect_default,
+  useId_default,
+  unsupportedProp_default,
+  useControlled_default,
+  useEventCallback_default2 as useEventCallback_default,
+  useForkRef_default,
+  useIsFocusVisible_default,
+  unstable_ClassNameGenerator
+};
+//# sourceMappingURL=chunk-ANTY7EHM.js.map

control-plane-ui/node_modules/.vite/deps/chunk-HXA6O6EE.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+export {
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __privateWrapper
+};
+//# sourceMappingURL=chunk-HXA6O6EE.js.map

control-plane-ui/node_modules/.vite/deps/chunk-HXA6O6EE.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

control-plane-ui/node_modules/.vite/deps/chunk-WDD75YPL.js

@@ -0,0 +1,47 @@
+import {
+  GlobalStyles_default
+} from "./chunk-ZHUI7O2A.js";
+import {
+  _extends,
+  defaultTheme_default,
+  identifier_default,
+  init_extends,
+  require_prop_types
+} from "./chunk-QLKRFDUE.js";
+import {
+  require_jsx_runtime
+} from "./chunk-WKPQ4ZTV.js";
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __toESM
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/@mui/material/GlobalStyles/GlobalStyles.js
+init_extends();
+var React = __toESM(require_react());
+var import_prop_types = __toESM(require_prop_types());
+var import_jsx_runtime = __toESM(require_jsx_runtime());
+function GlobalStyles(props) {
+  return (0, import_jsx_runtime.jsx)(GlobalStyles_default, _extends({}, props, {
+    defaultTheme: defaultTheme_default,
+    themeId: identifier_default
+  }));
+}
+true ? GlobalStyles.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The styles you want to apply globally.
+   */
+  styles: import_prop_types.default.oneOfType([import_prop_types.default.array, import_prop_types.default.func, import_prop_types.default.number, import_prop_types.default.object, import_prop_types.default.string, import_prop_types.default.bool])
+} : void 0;
+var GlobalStyles_default2 = GlobalStyles;
+
+export {
+  GlobalStyles_default2 as GlobalStyles_default
+};
+//# sourceMappingURL=chunk-WDD75YPL.js.map

control-plane-ui/node_modules/.vite/deps/chunk-WDD75YPL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../@mui/material/GlobalStyles/GlobalStyles.js"],
+  "sourcesContent": ["'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { GlobalStyles as SystemGlobalStyles } from '@mui/system';\nimport defaultTheme from '../styles/defaultTheme';\nimport THEME_ID from '../styles/identifier';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction GlobalStyles(props) {\n  return /*#__PURE__*/_jsx(SystemGlobalStyles, _extends({}, props, {\n    defaultTheme: defaultTheme,\n    themeId: THEME_ID\n  }));\n}\nprocess.env.NODE_ENV !== \"production\" ? GlobalStyles.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * The styles you want to apply globally.\n   */\n  styles: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.array, PropTypes.func, PropTypes.number, PropTypes.object, PropTypes.string, PropTypes.bool])\n} : void 0;\nexport default GlobalStyles;"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAEA;AACA,YAAuB;AACvB,wBAAsB;AAItB,yBAA4B;AAC5B,SAAS,aAAa,OAAO;AAC3B,aAAoB,mBAAAA,KAAK,sBAAoB,SAAS,CAAC,GAAG,OAAO;AAAA,IAC/D,cAAc;AAAA,IACd,SAAS;AAAA,EACX,CAAC,CAAC;AACJ;AACA,OAAwC,aAAa,YAAmC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQtF,QAAQ,kBAAAC,QAAgD,UAAU,CAAC,kBAAAA,QAAU,OAAO,kBAAAA,QAAU,MAAM,kBAAAA,QAAU,QAAQ,kBAAAA,QAAU,QAAQ,kBAAAA,QAAU,QAAQ,kBAAAA,QAAU,IAAI,CAAC;AAC3K,IAAI;AACJ,IAAOC,wBAAQ;",
+  "names": ["_jsx", "PropTypes", "GlobalStyles_default"]
+}

control-plane-ui/node_modules/.vite/deps/chunk-WHT54KGP.js

@@ -0,0 +1,124 @@
+import {
+  GlobalStyles_default
+} from "./chunk-WDD75YPL.js";
+import {
+  useDefaultProps
+} from "./chunk-4B2NWW42.js";
+import {
+  _extends,
+  init_extends,
+  require_prop_types
+} from "./chunk-QLKRFDUE.js";
+import {
+  require_jsx_runtime
+} from "./chunk-WKPQ4ZTV.js";
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __toESM
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/@mui/material/CssBaseline/CssBaseline.js
+init_extends();
+var React = __toESM(require_react());
+var import_prop_types = __toESM(require_prop_types());
+var import_jsx_runtime = __toESM(require_jsx_runtime());
+var import_jsx_runtime2 = __toESM(require_jsx_runtime());
+var html = (theme, enableColorScheme) => _extends({
+  WebkitFontSmoothing: "antialiased",
+  // Antialiasing.
+  MozOsxFontSmoothing: "grayscale",
+  // Antialiasing.
+  // Change from `box-sizing: content-box` so that `width`
+  // is not affected by `padding` or `border`.
+  boxSizing: "border-box",
+  // Fix font resize problem in iOS
+  WebkitTextSizeAdjust: "100%"
+}, enableColorScheme && !theme.vars && {
+  colorScheme: theme.palette.mode
+});
+var body = (theme) => _extends({
+  color: (theme.vars || theme).palette.text.primary
+}, theme.typography.body1, {
+  backgroundColor: (theme.vars || theme).palette.background.default,
+  "@media print": {
+    // Save printer ink.
+    backgroundColor: (theme.vars || theme).palette.common.white
+  }
+});
+var styles = (theme, enableColorScheme = false) => {
+  var _theme$components;
+  const colorSchemeStyles = {};
+  if (enableColorScheme && theme.colorSchemes) {
+    Object.entries(theme.colorSchemes).forEach(([key, scheme]) => {
+      var _scheme$palette;
+      colorSchemeStyles[theme.getColorSchemeSelector(key).replace(/\s*&/, "")] = {
+        colorScheme: (_scheme$palette = scheme.palette) == null ? void 0 : _scheme$palette.mode
+      };
+    });
+  }
+  let defaultStyles = _extends({
+    html: html(theme, enableColorScheme),
+    "*, *::before, *::after": {
+      boxSizing: "inherit"
+    },
+    "strong, b": {
+      fontWeight: theme.typography.fontWeightBold
+    },
+    body: _extends({
+      margin: 0
+    }, body(theme), {
+      // Add support for document.body.requestFullScreen().
+      // Other elements, if background transparent, are not supported.
+      "&::backdrop": {
+        backgroundColor: (theme.vars || theme).palette.background.default
+      }
+    })
+  }, colorSchemeStyles);
+  const themeOverrides = (_theme$components = theme.components) == null || (_theme$components = _theme$components.MuiCssBaseline) == null ? void 0 : _theme$components.styleOverrides;
+  if (themeOverrides) {
+    defaultStyles = [defaultStyles, themeOverrides];
+  }
+  return defaultStyles;
+};
+function CssBaseline(inProps) {
+  const props = useDefaultProps({
+    props: inProps,
+    name: "MuiCssBaseline"
+  });
+  const {
+    children,
+    enableColorScheme = false
+  } = props;
+  return (0, import_jsx_runtime2.jsxs)(React.Fragment, {
+    children: [(0, import_jsx_runtime.jsx)(GlobalStyles_default, {
+      styles: (theme) => styles(theme, enableColorScheme)
+    }), children]
+  });
+}
+true ? CssBaseline.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * You can wrap a node.
+   */
+  children: import_prop_types.default.node,
+  /**
+   * Enable `color-scheme` CSS property to use `theme.palette.mode`.
+   * For more details, check out https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme
+   * For browser support, check out https://caniuse.com/?search=color-scheme
+   * @default false
+   */
+  enableColorScheme: import_prop_types.default.bool
+} : void 0;
+var CssBaseline_default = CssBaseline;
+
+export {
+  html,
+  body,
+  CssBaseline_default
+};
+//# sourceMappingURL=chunk-WHT54KGP.js.map

control-plane-ui/node_modules/.vite/deps/chunk-WHT54KGP.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../@mui/material/CssBaseline/CssBaseline.js"],
+  "sourcesContent": ["'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { useDefaultProps } from '../DefaultPropsProvider';\nimport GlobalStyles from '../GlobalStyles';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nexport const html = (theme, enableColorScheme) => _extends({\n  WebkitFontSmoothing: 'antialiased',\n  // Antialiasing.\n  MozOsxFontSmoothing: 'grayscale',\n  // Antialiasing.\n  // Change from `box-sizing: content-box` so that `width`\n  // is not affected by `padding` or `border`.\n  boxSizing: 'border-box',\n  // Fix font resize problem in iOS\n  WebkitTextSizeAdjust: '100%'\n}, enableColorScheme && !theme.vars && {\n  colorScheme: theme.palette.mode\n});\nexport const body = theme => _extends({\n  color: (theme.vars || theme).palette.text.primary\n}, theme.typography.body1, {\n  backgroundColor: (theme.vars || theme).palette.background.default,\n  '@media print': {\n    // Save printer ink.\n    backgroundColor: (theme.vars || theme).palette.common.white\n  }\n});\nexport const styles = (theme, enableColorScheme = false) => {\n  var _theme$components;\n  const colorSchemeStyles = {};\n  if (enableColorScheme && theme.colorSchemes) {\n    Object.entries(theme.colorSchemes).forEach(([key, scheme]) => {\n      var _scheme$palette;\n      colorSchemeStyles[theme.getColorSchemeSelector(key).replace(/\\s*&/, '')] = {\n        colorScheme: (_scheme$palette = scheme.palette) == null ? void 0 : _scheme$palette.mode\n      };\n    });\n  }\n  let defaultStyles = _extends({\n    html: html(theme, enableColorScheme),\n    '*, *::before, *::after': {\n      boxSizing: 'inherit'\n    },\n    'strong, b': {\n      fontWeight: theme.typography.fontWeightBold\n    },\n    body: _extends({\n      margin: 0\n    }, body(theme), {\n      // Add support for document.body.requestFullScreen().\n      // Other elements, if background transparent, are not supported.\n      '&::backdrop': {\n        backgroundColor: (theme.vars || theme).palette.background.default\n      }\n    })\n  }, colorSchemeStyles);\n  const themeOverrides = (_theme$components = theme.components) == null || (_theme$components = _theme$components.MuiCssBaseline) == null ? void 0 : _theme$components.styleOverrides;\n  if (themeOverrides) {\n    defaultStyles = [defaultStyles, themeOverrides];\n  }\n  return defaultStyles;\n};\n\n/**\n * Kickstart an elegant, consistent, and simple baseline to build upon.\n */\nfunction CssBaseline(inProps) {\n  const props = useDefaultProps({\n    props: inProps,\n    name: 'MuiCssBaseline'\n  });\n  const {\n    children,\n    enableColorScheme = false\n  } = props;\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [/*#__PURE__*/_jsx(GlobalStyles, {\n      styles: theme => styles(theme, enableColorScheme)\n    }), children]\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? CssBaseline.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * You can wrap a node.\n   */\n  children: PropTypes.node,\n  /**\n   * Enable `color-scheme` CSS property to use `theme.palette.mode`.\n   * For more details, check out https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme\n   * For browser support, check out https://caniuse.com/?search=color-scheme\n   * @default false\n   */\n  enableColorScheme: PropTypes.bool\n} : void 0;\nexport default CssBaseline;"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAEA;AACA,YAAuB;AACvB,wBAAsB;AAGtB,yBAA4B;AAC5B,IAAAA,sBAA8B;AACvB,IAAM,OAAO,CAAC,OAAO,sBAAsB,SAAS;AAAA,EACzD,qBAAqB;AAAA;AAAA,EAErB,qBAAqB;AAAA;AAAA;AAAA;AAAA,EAIrB,WAAW;AAAA;AAAA,EAEX,sBAAsB;AACxB,GAAG,qBAAqB,CAAC,MAAM,QAAQ;AAAA,EACrC,aAAa,MAAM,QAAQ;AAC7B,CAAC;AACM,IAAM,OAAO,WAAS,SAAS;AAAA,EACpC,QAAQ,MAAM,QAAQ,OAAO,QAAQ,KAAK;AAC5C,GAAG,MAAM,WAAW,OAAO;AAAA,EACzB,kBAAkB,MAAM,QAAQ,OAAO,QAAQ,WAAW;AAAA,EAC1D,gBAAgB;AAAA;AAAA,IAEd,kBAAkB,MAAM,QAAQ,OAAO,QAAQ,OAAO;AAAA,EACxD;AACF,CAAC;AACM,IAAM,SAAS,CAAC,OAAO,oBAAoB,UAAU;AAC1D,MAAI;AACJ,QAAM,oBAAoB,CAAC;AAC3B,MAAI,qBAAqB,MAAM,cAAc;AAC3C,WAAO,QAAQ,MAAM,YAAY,EAAE,QAAQ,CAAC,CAAC,KAAK,MAAM,MAAM;AAC5D,UAAI;AACJ,wBAAkB,MAAM,uBAAuB,GAAG,EAAE,QAAQ,QAAQ,EAAE,CAAC,IAAI;AAAA,QACzE,cAAc,kBAAkB,OAAO,YAAY,OAAO,SAAS,gBAAgB;AAAA,MACrF;AAAA,IACF,CAAC;AAAA,EACH;AACA,MAAI,gBAAgB,SAAS;AAAA,IAC3B,MAAM,KAAK,OAAO,iBAAiB;AAAA,IACnC,0BAA0B;AAAA,MACxB,WAAW;AAAA,IACb;AAAA,IACA,aAAa;AAAA,MACX,YAAY,MAAM,WAAW;AAAA,IAC/B;AAAA,IACA,MAAM,SAAS;AAAA,MACb,QAAQ;AAAA,IACV,GAAG,KAAK,KAAK,GAAG;AAAA;AAAA;AAAA,MAGd,eAAe;AAAA,QACb,kBAAkB,MAAM,QAAQ,OAAO,QAAQ,WAAW;AAAA,MAC5D;AAAA,IACF,CAAC;AAAA,EACH,GAAG,iBAAiB;AACpB,QAAM,kBAAkB,oBAAoB,MAAM,eAAe,SAAS,oBAAoB,kBAAkB,mBAAmB,OAAO,SAAS,kBAAkB;AACrK,MAAI,gBAAgB;AAClB,oBAAgB,CAAC,eAAe,cAAc;AAAA,EAChD;AACA,SAAO;AACT;AAKA,SAAS,YAAY,SAAS;AAC5B,QAAM,QAAQ,gBAAgB;AAAA,IAC5B,OAAO;AAAA,IACP,MAAM;AAAA,EACR,CAAC;AACD,QAAM;AAAA,IACJ;AAAA,IACA,oBAAoB;AAAA,EACtB,IAAI;AACJ,aAAoB,oBAAAC,MAAY,gBAAU;AAAA,IACxC,UAAU,KAAc,mBAAAC,KAAK,sBAAc;AAAA,MACzC,QAAQ,WAAS,OAAO,OAAO,iBAAiB;AAAA,IAClD,CAAC,GAAG,QAAQ;AAAA,EACd,CAAC;AACH;AACA,OAAwC,YAAY,YAAmC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQrF,UAAU,kBAAAC,QAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOpB,mBAAmB,kBAAAA,QAAU;AAC/B,IAAI;AACJ,IAAO,sBAAQ;",
+  "names": ["import_jsx_runtime", "_jsxs", "_jsx", "PropTypes"]
+}

control-plane-ui/node_modules/.vite/deps/chunk-WKPQ4ZTV.js

@@ -0,0 +1,928 @@
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __commonJS
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/react/cjs/react-jsx-runtime.development.js
+var require_react_jsx_runtime_development = __commonJS({
+  "node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
+    "use strict";
+    if (true) {
+      (function() {
+        "use strict";
+        var React = require_react();
+        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) {
+          {
+            var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
+            var stack = ReactDebugCurrentFrame2.getStackAddendum();
+            if (stack !== "") {
+              format += "%s";
+              args = args.concat([stack]);
+            }
+            var argsWithFormat = args.map(function(item) {
+              return String(item);
+            });
+            argsWithFormat.unshift("Warning: " + format);
+            Function.prototype.apply.call(console[level], console, argsWithFormat);
+          }
+        }
+        var enableScopeAPI = false;
+        var enableCacheElement = false;
+        var enableTransitionTracing = false;
+        var enableLegacyHidden = false;
+        var enableDebugTracing = false;
+        var REACT_MODULE_REFERENCE;
+        {
+          REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
+        }
+        function isValidElementType(type) {
+          if (typeof type === "string" || typeof type === "function") {
+            return true;
+          }
+          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 !== void 0) {
+              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;
+        }
+        function getContextName(type) {
+          return type.displayName || "Context";
+        }
+        function getComponentNameFromType(type) {
+          if (type == null) {
+            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;
+                }
+              }
+            }
+          }
+          return null;
+        }
+        var assign = Object.assign;
+        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) {
+              prevLog = console.log;
+              prevInfo = console.info;
+              prevWarn = console.warn;
+              prevError = console.error;
+              prevGroup = console.group;
+              prevGroupCollapsed = console.groupCollapsed;
+              prevGroupEnd = console.groupEnd;
+              var props = {
+                configurable: true,
+                enumerable: true,
+                value: disabledLog,
+                writable: true
+              };
+              Object.defineProperties(console, {
+                info: props,
+                log: props,
+                warn: props,
+                error: props,
+                group: props,
+                groupCollapsed: props,
+                groupEnd: props
+              });
+            }
+            disabledDepth++;
+          }
+        }
+        function reenableLogs() {
+          {
+            disabledDepth--;
+            if (disabledDepth === 0) {
+              var props = {
+                configurable: true,
+                enumerable: true,
+                writable: true
+              };
+              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
+                })
+              });
+            }
+            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 === void 0) {
+              try {
+                throw Error();
+              } catch (x) {
+                var match = x.stack.trim().match(/\n( *(at )?)/);
+                prefix = match && match[1] || "";
+              }
+            }
+            return "\n" + prefix + name;
+          }
+        }
+        var reentry = false;
+        var componentFrameCache;
+        {
+          var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+          componentFrameCache = new PossiblyWeakMap();
+        }
+        function describeNativeComponentFrame(fn, construct) {
+          if (!fn || reentry) {
+            return "";
+          }
+          {
+            var frame = componentFrameCache.get(fn);
+            if (frame !== void 0) {
+              return frame;
+            }
+          }
+          var control;
+          reentry = true;
+          var previousPrepareStackTrace = Error.prepareStackTrace;
+          Error.prepareStackTrace = void 0;
+          var previousDispatcher;
+          {
+            previousDispatcher = ReactCurrentDispatcher.current;
+            ReactCurrentDispatcher.current = null;
+            disableLogs();
+          }
+          try {
+            if (construct) {
+              var Fake = function() {
+                throw Error();
+              };
+              Object.defineProperty(Fake.prototype, "props", {
+                set: function() {
+                  throw Error();
+                }
+              });
+              if (typeof Reflect === "object" && Reflect.construct) {
+                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) {
+            if (sample && control && typeof sample.stack === "string") {
+              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]) {
+                c--;
+              }
+              for (; s >= 1 && c >= 0; s--, c--) {
+                if (sampleLines[s] !== controlLines[c]) {
+                  if (s !== 1 || c !== 1) {
+                    do {
+                      s--;
+                      c--;
+                      if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                        var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
+                        if (fn.displayName && _frame.includes("<anonymous>")) {
+                          _frame = _frame.replace("<anonymous>", fn.displayName);
+                        }
+                        {
+                          if (typeof fn === "function") {
+                            componentFrameCache.set(fn, _frame);
+                          }
+                        }
+                        return _frame;
+                      }
+                    } while (s >= 1 && c >= 0);
+                  }
+                  break;
+                }
+              }
+            }
+          } finally {
+            reentry = false;
+            {
+              ReactCurrentDispatcher.current = previousDispatcher;
+              reenableLogs();
+            }
+            Error.prepareStackTrace = previousPrepareStackTrace;
+          }
+          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:
+                return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+              case REACT_LAZY_TYPE: {
+                var lazyComponent = type;
+                var payload = lazyComponent._payload;
+                var init = lazyComponent._init;
+                try {
+                  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) {
+          {
+            var has = Function.call.bind(hasOwnProperty);
+            for (var typeSpecName in typeSpecs) {
+              if (has(typeSpecs, typeSpecName)) {
+                var error$1 = void 0;
+                try {
+                  if (typeof typeSpecs[typeSpecName] !== "function") {
+                    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)) {
+                  loggedTypeFailures[error$1.message] = true;
+                  setCurrentlyValidatingElement(element);
+                  error("Failed %s type: %s", location, error$1.message);
+                  setCurrentlyValidatingElement(null);
+                }
+              }
+            }
+          }
+        }
+        var isArrayImpl = Array.isArray;
+        function isArray(a) {
+          return isArrayImpl(a);
+        }
+        function typeName(value) {
+          {
+            var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
+            var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+            return type;
+          }
+        }
+        function willCoercionThrow(value) {
+          {
+            try {
+              testStringCoercion(value);
+              return false;
+            } catch (e) {
+              return true;
+            }
+          }
+        }
+        function testStringCoercion(value) {
+          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);
+            }
+          }
+        }
+        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 !== void 0;
+        }
+        function hasValidKey(config) {
+          {
+            if (hasOwnProperty.call(config, "key")) {
+              var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+              if (getter && getter.isReactWarning) {
+                return false;
+              }
+            }
+          }
+          return config.key !== void 0;
+        }
+        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
+            });
+          }
+        }
+        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,
+            key,
+            ref,
+            props,
+            // Record the component responsible for creating this element.
+            _owner: owner
+          };
+          {
+            element._store = {};
+            Object.defineProperty(element._store, "validated", {
+              configurable: false,
+              enumerable: false,
+              writable: true,
+              value: false
+            });
+            Object.defineProperty(element, "_self", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: self
+            });
+            Object.defineProperty(element, "_source", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: source
+            });
+            if (Object.freeze) {
+              Object.freeze(element.props);
+              Object.freeze(element);
+            }
+          }
+          return element;
+        };
+        function jsxDEV(type, config, maybeKey, source, self) {
+          {
+            var propName;
+            var props = {};
+            var key = null;
+            var ref = null;
+            if (maybeKey !== void 0) {
+              {
+                checkKeyStringCoercion(maybeKey);
+              }
+              key = "" + maybeKey;
+            }
+            if (hasValidKey(config)) {
+              {
+                checkKeyStringCoercion(config.key);
+              }
+              key = "" + config.key;
+            }
+            if (hasValidRef(config)) {
+              ref = config.ref;
+              warnIfStringRefCannotBeAutoConverted(config, self);
+            }
+            for (propName in config) {
+              if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                props[propName] = config[propName];
+              }
+            }
+            if (type && type.defaultProps) {
+              var defaultProps = type.defaultProps;
+              for (propName in defaultProps) {
+                if (props[propName] === void 0) {
+                  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;
+        }
+        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 !== void 0) {
+              var fileName = source.fileName.replace(/^.*[\\\/]/, "");
+              var lineNumber = source.lineNumber;
+              return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
+            }
+            return "";
+          }
+        }
+        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;
+          }
+        }
+        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;
+            var childOwner = "";
+            if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
+              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);
+          }
+        }
+        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)) {
+              if (node._store) {
+                node._store.validated = true;
+              }
+            } else if (node) {
+              var iteratorFn = getIteratorFn(node);
+              if (typeof iteratorFn === "function") {
+                if (iteratorFn !== node.entries) {
+                  var iterator = iteratorFn.call(node);
+                  var step;
+                  while (!(step = iterator.next()).done) {
+                    if (isValidElement(step.value)) {
+                      validateExplicitKey(step.value, parentType);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        function validatePropTypes(element) {
+          {
+            var type = element.type;
+            if (type === null || type === void 0 || 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) {
+              var name = getComponentNameFromType(type);
+              checkPropTypes(propTypes, element.props, "prop", name, element);
+            } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
+              propTypesMisspellWarningShown = true;
+              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.");
+            }
+          }
+        }
+        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);
+            }
+          }
+        }
+        var didWarnAboutKeySpread = {};
+        function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
+          {
+            var validType = isValidElementType(type);
+            if (!validType) {
+              var info = "";
+              if (type === void 0 || 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 !== void 0 && 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);
+            if (element == null) {
+              return element;
+            }
+            if (validType) {
+              var children = props.children;
+              if (children !== void 0) {
+                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 (hasOwnProperty.call(props, "key")) {
+                var componentName = getComponentNameFromType(type);
+                var keys = Object.keys(props).filter(function(k) {
+                  return k !== "key";
+                });
+                var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+                if (!didWarnAboutKeySpread[componentName + beforeExample]) {
+                  var afterExample = keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}";
+                  error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);
+                  didWarnAboutKeySpread[componentName + beforeExample] = true;
+                }
+              }
+            }
+            if (type === REACT_FRAGMENT_TYPE) {
+              validateFragmentProps(element);
+            } else {
+              validatePropTypes(element);
+            }
+            return element;
+          }
+        }
+        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;
+        var jsxs = jsxWithValidationStatic;
+        exports.Fragment = REACT_FRAGMENT_TYPE;
+        exports.jsx = jsx;
+        exports.jsxs = jsxs;
+      })();
+    }
+  }
+});
+
+// node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS({
+  "node_modules/react/jsx-runtime.js"(exports, module) {
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_jsx_runtime_development();
+    }
+  }
+});
+
+export {
+  require_jsx_runtime
+};
+/*! Bundled license information:
+
+react/cjs/react-jsx-runtime.development.js:
+  (**
+   * @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.
+   *)
+*/
+//# sourceMappingURL=chunk-WKPQ4ZTV.js.map

control-plane-ui/node_modules/.vite/deps/chunk-Y5IG6O7D.js

@@ -0,0 +1,736 @@
+import {
+  ThemeProvider_default,
+  createCssVarsProvider,
+  createGetCssVar,
+  prepareCssVars_default,
+  useThemeProps,
+  useTheme_default
+} from "./chunk-ZHUI7O2A.js";
+import {
+  _extends,
+  _objectWithoutPropertiesLoose,
+  createBreakpoints,
+  createSpacing,
+  createTheme_default2 as createTheme_default,
+  createTypography,
+  deepmerge,
+  defaultSxConfig_default,
+  defaultTheme_default,
+  identifier_default,
+  init_deepmerge,
+  init_extends,
+  init_formatMuiErrorMessage,
+  require_colorManipulator,
+  require_prop_types,
+  styleFunctionSx_default
+} from "./chunk-QLKRFDUE.js";
+import {
+  require_jsx_runtime
+} from "./chunk-WKPQ4ZTV.js";
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __toESM
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/@mui/material/styles/index.js
+init_formatMuiErrorMessage();
+
+// node_modules/@mui/material/styles/adaptV4Theme.js
+init_extends();
+var _excluded = ["defaultProps", "mixins", "overrides", "palette", "props", "styleOverrides"];
+var _excluded2 = ["type", "mode"];
+function adaptV4Theme(inputTheme) {
+  if (true) {
+    console.warn(["MUI: adaptV4Theme() is deprecated.", "Follow the upgrade guide on https://mui.com/r/migration-v4#theme."].join("\n"));
+  }
+  const {
+    defaultProps = {},
+    mixins = {},
+    overrides = {},
+    palette = {},
+    props = {},
+    styleOverrides = {}
+  } = inputTheme, other = _objectWithoutPropertiesLoose(inputTheme, _excluded);
+  const theme = _extends({}, other, {
+    components: {}
+  });
+  Object.keys(defaultProps).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.defaultProps = defaultProps[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(props).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.defaultProps = props[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(styleOverrides).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.styleOverrides = styleOverrides[component];
+    theme.components[component] = componentValue;
+  });
+  Object.keys(overrides).forEach((component) => {
+    const componentValue = theme.components[component] || {};
+    componentValue.styleOverrides = overrides[component];
+    theme.components[component] = componentValue;
+  });
+  theme.spacing = createSpacing(inputTheme.spacing);
+  const breakpoints = createBreakpoints(inputTheme.breakpoints || {});
+  const spacing = theme.spacing;
+  theme.mixins = _extends({
+    gutters: (styles = {}) => {
+      return _extends({
+        paddingLeft: spacing(2),
+        paddingRight: spacing(2)
+      }, styles, {
+        [breakpoints.up("sm")]: _extends({
+          paddingLeft: spacing(3),
+          paddingRight: spacing(3)
+        }, styles[breakpoints.up("sm")])
+      });
+    }
+  }, mixins);
+  const {
+    type: typeInput,
+    mode: modeInput
+  } = palette, paletteRest = _objectWithoutPropertiesLoose(palette, _excluded2);
+  const finalMode = modeInput || typeInput || "light";
+  theme.palette = _extends({
+    // theme.palette.text.hint
+    text: {
+      hint: finalMode === "dark" ? "rgba(255, 255, 255, 0.5)" : "rgba(0, 0, 0, 0.38)"
+    },
+    mode: finalMode,
+    type: finalMode
+  }, paletteRest);
+  return theme;
+}
+
+// node_modules/@mui/material/styles/createMuiStrictModeTheme.js
+init_deepmerge();
+function createMuiStrictModeTheme(options, ...args) {
+  return createTheme_default(deepmerge({
+    unstable_strictMode: true
+  }, options), ...args);
+}
+
+// node_modules/@mui/material/styles/createStyles.js
+var warnedOnce = false;
+function createStyles(styles) {
+  if (!warnedOnce) {
+    console.warn(["MUI: createStyles from @mui/material/styles is deprecated.", "Please use @mui/styles/createStyles"].join("\n"));
+    warnedOnce = true;
+  }
+  return styles;
+}
+
+// node_modules/@mui/material/styles/cssUtils.js
+function isUnitless(value) {
+  return String(parseFloat(value)).length === String(value).length;
+}
+function getUnit(input) {
+  return String(input).match(/[\d.\-+]*\s*(.*)/)[1] || "";
+}
+function toUnitless(length) {
+  return parseFloat(length);
+}
+function convertLength(baseFontSize) {
+  return (length, toUnit) => {
+    const fromUnit = getUnit(length);
+    if (fromUnit === toUnit) {
+      return length;
+    }
+    let pxLength = toUnitless(length);
+    if (fromUnit !== "px") {
+      if (fromUnit === "em") {
+        pxLength = toUnitless(length) * toUnitless(baseFontSize);
+      } else if (fromUnit === "rem") {
+        pxLength = toUnitless(length) * toUnitless(baseFontSize);
+      }
+    }
+    let outputLength = pxLength;
+    if (toUnit !== "px") {
+      if (toUnit === "em") {
+        outputLength = pxLength / toUnitless(baseFontSize);
+      } else if (toUnit === "rem") {
+        outputLength = pxLength / toUnitless(baseFontSize);
+      } else {
+        return length;
+      }
+    }
+    return parseFloat(outputLength.toFixed(5)) + toUnit;
+  };
+}
+function alignProperty({
+  size,
+  grid
+}) {
+  const sizeBelow = size - size % grid;
+  const sizeAbove = sizeBelow + grid;
+  return size - sizeBelow < sizeAbove - size ? sizeBelow : sizeAbove;
+}
+function fontGrid({
+  lineHeight,
+  pixels,
+  htmlFontSize
+}) {
+  return pixels / (lineHeight * htmlFontSize);
+}
+function responsiveProperty({
+  cssProperty,
+  min,
+  max,
+  unit = "rem",
+  breakpoints = [600, 900, 1200],
+  transform = null
+}) {
+  const output = {
+    [cssProperty]: `${min}${unit}`
+  };
+  const factor = (max - min) / breakpoints[breakpoints.length - 1];
+  breakpoints.forEach((breakpoint) => {
+    let value = min + factor * breakpoint;
+    if (transform !== null) {
+      value = transform(value);
+    }
+    output[`@media (min-width:${breakpoint}px)`] = {
+      [cssProperty]: `${Math.round(value * 1e4) / 1e4}${unit}`
+    };
+  });
+  return output;
+}
+
+// node_modules/@mui/material/styles/responsiveFontSizes.js
+init_extends();
+init_formatMuiErrorMessage();
+function responsiveFontSizes(themeInput, options = {}) {
+  const {
+    breakpoints = ["sm", "md", "lg"],
+    disableAlign = false,
+    factor = 2,
+    variants = ["h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "caption", "button", "overline"]
+  } = options;
+  const theme = _extends({}, themeInput);
+  theme.typography = _extends({}, theme.typography);
+  const typography = theme.typography;
+  const convert = convertLength(typography.htmlFontSize);
+  const breakpointValues = breakpoints.map((x) => theme.breakpoints.values[x]);
+  variants.forEach((variant) => {
+    const style = typography[variant];
+    if (!style) {
+      return;
+    }
+    const remFontSize = parseFloat(convert(style.fontSize, "rem"));
+    if (remFontSize <= 1) {
+      return;
+    }
+    const maxFontSize = remFontSize;
+    const minFontSize = 1 + (maxFontSize - 1) / factor;
+    let {
+      lineHeight
+    } = style;
+    if (!isUnitless(lineHeight) && !disableAlign) {
+      throw new Error(true ? `MUI: Unsupported non-unitless line height with grid alignment.
+Use unitless line heights instead.` : formatMuiErrorMessage(6));
+    }
+    if (!isUnitless(lineHeight)) {
+      lineHeight = parseFloat(convert(lineHeight, "rem")) / parseFloat(remFontSize);
+    }
+    let transform = null;
+    if (!disableAlign) {
+      transform = (value) => alignProperty({
+        size: value,
+        grid: fontGrid({
+          pixels: 4,
+          lineHeight,
+          htmlFontSize: typography.htmlFontSize
+        })
+      });
+    }
+    typography[variant] = _extends({}, style, responsiveProperty({
+      cssProperty: "fontSize",
+      min: minFontSize,
+      max: maxFontSize,
+      unit: "rem",
+      breakpoints: breakpointValues,
+      transform
+    }));
+  });
+  return theme;
+}
+
+// node_modules/@mui/material/styles/useTheme.js
+var React = __toESM(require_react());
+function useTheme() {
+  const theme = useTheme_default(defaultTheme_default);
+  if (true) {
+    React.useDebugValue(theme);
+  }
+  return theme[identifier_default] || theme;
+}
+
+// node_modules/@mui/material/styles/useThemeProps.js
+function useThemeProps2({
+  props,
+  name
+}) {
+  return useThemeProps({
+    props,
+    name,
+    defaultTheme: defaultTheme_default,
+    themeId: identifier_default
+  });
+}
+
+// node_modules/@mui/material/styles/ThemeProvider.js
+init_extends();
+var React2 = __toESM(require_react());
+var import_prop_types = __toESM(require_prop_types());
+var import_jsx_runtime = __toESM(require_jsx_runtime());
+var _excluded3 = ["theme"];
+function ThemeProvider(_ref) {
+  let {
+    theme: themeInput
+  } = _ref, props = _objectWithoutPropertiesLoose(_ref, _excluded3);
+  const scopedTheme = themeInput[identifier_default];
+  let finalTheme = scopedTheme || themeInput;
+  if (typeof themeInput !== "function") {
+    if (scopedTheme && !scopedTheme.vars) {
+      finalTheme = _extends({}, scopedTheme, {
+        vars: null
+      });
+    } else if (themeInput && !themeInput.vars) {
+      finalTheme = _extends({}, themeInput, {
+        vars: null
+      });
+    }
+  }
+  return (0, import_jsx_runtime.jsx)(ThemeProvider_default, _extends({}, props, {
+    themeId: scopedTheme ? identifier_default : void 0,
+    theme: finalTheme
+  }));
+}
+true ? ThemeProvider.propTypes = {
+  /**
+   * Your component tree.
+   */
+  children: import_prop_types.default.node,
+  /**
+   * A theme object. You can provide a function to extend the outer theme.
+   */
+  theme: import_prop_types.default.oneOfType([import_prop_types.default.object, import_prop_types.default.func]).isRequired
+} : void 0;
+
+// node_modules/@mui/material/styles/makeStyles.js
+init_formatMuiErrorMessage();
+function makeStyles() {
+  throw new Error(true ? `MUI: makeStyles is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : formatMuiErrorMessage(14));
+}
+
+// node_modules/@mui/material/styles/withStyles.js
+init_formatMuiErrorMessage();
+function withStyles() {
+  throw new Error(true ? `MUI: withStyles is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : formatMuiErrorMessage(15));
+}
+
+// node_modules/@mui/material/styles/withTheme.js
+init_formatMuiErrorMessage();
+function withTheme() {
+  throw new Error(true ? `MUI: withTheme is no longer exported from @mui/material/styles.
+You have to import it from @mui/styles.
+See https://mui.com/r/migration-v4/#mui-material-styles for more details.` : formatMuiErrorMessage(16));
+}
+
+// node_modules/@mui/material/styles/CssVarsProvider.js
+init_extends();
+
+// node_modules/@mui/material/styles/experimental_extendTheme.js
+init_extends();
+init_deepmerge();
+var import_colorManipulator = __toESM(require_colorManipulator());
+
+// node_modules/@mui/material/styles/shouldSkipGeneratingVar.js
+function shouldSkipGeneratingVar(keys) {
+  var _keys$;
+  return !!keys[0].match(/(cssVarPrefix|modularCssLayers|typography|mixins|breakpoints|direction|transitions)/) || !!keys[0].match(/sxConfig$/) || // ends with sxConfig
+  keys[0] === "palette" && !!((_keys$ = keys[1]) != null && _keys$.match(/(mode|contrastThreshold|tonalOffset)/));
+}
+
+// node_modules/@mui/material/styles/getOverlayAlpha.js
+var getOverlayAlpha = (elevation) => {
+  let alphaValue;
+  if (elevation < 1) {
+    alphaValue = 5.11916 * elevation ** 2;
+  } else {
+    alphaValue = 4.5 * Math.log(elevation + 1) + 2;
+  }
+  return (alphaValue / 100).toFixed(2);
+};
+var getOverlayAlpha_default = getOverlayAlpha;
+
+// node_modules/@mui/material/styles/experimental_extendTheme.js
+var _excluded4 = ["colorSchemes", "cssVarPrefix", "shouldSkipGeneratingVar"];
+var _excluded22 = ["palette"];
+var defaultDarkOverlays = [...Array(25)].map((_, index) => {
+  if (index === 0) {
+    return void 0;
+  }
+  const overlay = getOverlayAlpha_default(index);
+  return `linear-gradient(rgba(255 255 255 / ${overlay}), rgba(255 255 255 / ${overlay}))`;
+});
+function assignNode(obj, keys) {
+  keys.forEach((k) => {
+    if (!obj[k]) {
+      obj[k] = {};
+    }
+  });
+}
+function setColor(obj, key, defaultValue) {
+  if (!obj[key] && defaultValue) {
+    obj[key] = defaultValue;
+  }
+}
+function toRgb(color) {
+  if (!color || !color.startsWith("hsl")) {
+    return color;
+  }
+  return (0, import_colorManipulator.hslToRgb)(color);
+}
+function setColorChannel(obj, key) {
+  if (!(`${key}Channel` in obj)) {
+    obj[`${key}Channel`] = (0, import_colorManipulator.private_safeColorChannel)(toRgb(obj[key]), `MUI: Can't create \`palette.${key}Channel\` because \`palette.${key}\` is not one of these formats: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().
+To suppress this warning, you need to explicitly provide the \`palette.${key}Channel\` as a string (in rgb format, for example "12 12 12") or undefined if you want to remove the channel token.`);
+  }
+}
+var silent = (fn) => {
+  try {
+    return fn();
+  } catch (error) {
+  }
+  return void 0;
+};
+var createGetCssVar2 = (cssVarPrefix = "mui") => createGetCssVar(cssVarPrefix);
+function extendTheme(options = {}, ...args) {
+  var _colorSchemesInput$li, _colorSchemesInput$da, _colorSchemesInput$li2, _colorSchemesInput$li3, _colorSchemesInput$da2, _colorSchemesInput$da3;
+  const {
+    colorSchemes: colorSchemesInput = {},
+    cssVarPrefix = "mui",
+    shouldSkipGeneratingVar: shouldSkipGeneratingVar2 = shouldSkipGeneratingVar
+  } = options, input = _objectWithoutPropertiesLoose(options, _excluded4);
+  const getCssVar = createGetCssVar2(cssVarPrefix);
+  const _createThemeWithoutVa = createTheme_default(_extends({}, input, colorSchemesInput.light && {
+    palette: (_colorSchemesInput$li = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li.palette
+  })), {
+    palette: lightPalette
+  } = _createThemeWithoutVa, muiTheme = _objectWithoutPropertiesLoose(_createThemeWithoutVa, _excluded22);
+  const {
+    palette: darkPalette
+  } = createTheme_default({
+    palette: _extends({
+      mode: "dark"
+    }, (_colorSchemesInput$da = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da.palette)
+  });
+  let theme = _extends({}, muiTheme, {
+    cssVarPrefix,
+    getCssVar,
+    colorSchemes: _extends({}, colorSchemesInput, {
+      light: _extends({}, colorSchemesInput.light, {
+        palette: lightPalette,
+        opacity: _extends({
+          inputPlaceholder: 0.42,
+          inputUnderline: 0.42,
+          switchTrackDisabled: 0.12,
+          switchTrack: 0.38
+        }, (_colorSchemesInput$li2 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li2.opacity),
+        overlays: ((_colorSchemesInput$li3 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li3.overlays) || []
+      }),
+      dark: _extends({}, colorSchemesInput.dark, {
+        palette: darkPalette,
+        opacity: _extends({
+          inputPlaceholder: 0.5,
+          inputUnderline: 0.7,
+          switchTrackDisabled: 0.2,
+          switchTrack: 0.3
+        }, (_colorSchemesInput$da2 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da2.opacity),
+        overlays: ((_colorSchemesInput$da3 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da3.overlays) || defaultDarkOverlays
+      })
+    })
+  });
+  Object.keys(theme.colorSchemes).forEach((key) => {
+    const palette = theme.colorSchemes[key].palette;
+    const setCssVarColor = (cssVar) => {
+      const tokens = cssVar.split("-");
+      const color = tokens[1];
+      const colorToken = tokens[2];
+      return getCssVar(cssVar, palette[color][colorToken]);
+    };
+    if (key === "light") {
+      setColor(palette.common, "background", "#fff");
+      setColor(palette.common, "onBackground", "#000");
+    } else {
+      setColor(palette.common, "background", "#000");
+      setColor(palette.common, "onBackground", "#fff");
+    }
+    assignNode(palette, ["Alert", "AppBar", "Avatar", "Button", "Chip", "FilledInput", "LinearProgress", "Skeleton", "Slider", "SnackbarContent", "SpeedDialAction", "StepConnector", "StepContent", "Switch", "TableCell", "Tooltip"]);
+    if (key === "light") {
+      setColor(palette.Alert, "errorColor", (0, import_colorManipulator.private_safeDarken)(palette.error.light, 0.6));
+      setColor(palette.Alert, "infoColor", (0, import_colorManipulator.private_safeDarken)(palette.info.light, 0.6));
+      setColor(palette.Alert, "successColor", (0, import_colorManipulator.private_safeDarken)(palette.success.light, 0.6));
+      setColor(palette.Alert, "warningColor", (0, import_colorManipulator.private_safeDarken)(palette.warning.light, 0.6));
+      setColor(palette.Alert, "errorFilledBg", setCssVarColor("palette-error-main"));
+      setColor(palette.Alert, "infoFilledBg", setCssVarColor("palette-info-main"));
+      setColor(palette.Alert, "successFilledBg", setCssVarColor("palette-success-main"));
+      setColor(palette.Alert, "warningFilledBg", setCssVarColor("palette-warning-main"));
+      setColor(palette.Alert, "errorFilledColor", silent(() => lightPalette.getContrastText(palette.error.main)));
+      setColor(palette.Alert, "infoFilledColor", silent(() => lightPalette.getContrastText(palette.info.main)));
+      setColor(palette.Alert, "successFilledColor", silent(() => lightPalette.getContrastText(palette.success.main)));
+      setColor(palette.Alert, "warningFilledColor", silent(() => lightPalette.getContrastText(palette.warning.main)));
+      setColor(palette.Alert, "errorStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.error.light, 0.9));
+      setColor(palette.Alert, "infoStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.info.light, 0.9));
+      setColor(palette.Alert, "successStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.success.light, 0.9));
+      setColor(palette.Alert, "warningStandardBg", (0, import_colorManipulator.private_safeLighten)(palette.warning.light, 0.9));
+      setColor(palette.Alert, "errorIconColor", setCssVarColor("palette-error-main"));
+      setColor(palette.Alert, "infoIconColor", setCssVarColor("palette-info-main"));
+      setColor(palette.Alert, "successIconColor", setCssVarColor("palette-success-main"));
+      setColor(palette.Alert, "warningIconColor", setCssVarColor("palette-warning-main"));
+      setColor(palette.AppBar, "defaultBg", setCssVarColor("palette-grey-100"));
+      setColor(palette.Avatar, "defaultBg", setCssVarColor("palette-grey-400"));
+      setColor(palette.Button, "inheritContainedBg", setCssVarColor("palette-grey-300"));
+      setColor(palette.Button, "inheritContainedHoverBg", setCssVarColor("palette-grey-A100"));
+      setColor(palette.Chip, "defaultBorder", setCssVarColor("palette-grey-400"));
+      setColor(palette.Chip, "defaultAvatarColor", setCssVarColor("palette-grey-700"));
+      setColor(palette.Chip, "defaultIconColor", setCssVarColor("palette-grey-700"));
+      setColor(palette.FilledInput, "bg", "rgba(0, 0, 0, 0.06)");
+      setColor(palette.FilledInput, "hoverBg", "rgba(0, 0, 0, 0.09)");
+      setColor(palette.FilledInput, "disabledBg", "rgba(0, 0, 0, 0.12)");
+      setColor(palette.LinearProgress, "primaryBg", (0, import_colorManipulator.private_safeLighten)(palette.primary.main, 0.62));
+      setColor(palette.LinearProgress, "secondaryBg", (0, import_colorManipulator.private_safeLighten)(palette.secondary.main, 0.62));
+      setColor(palette.LinearProgress, "errorBg", (0, import_colorManipulator.private_safeLighten)(palette.error.main, 0.62));
+      setColor(palette.LinearProgress, "infoBg", (0, import_colorManipulator.private_safeLighten)(palette.info.main, 0.62));
+      setColor(palette.LinearProgress, "successBg", (0, import_colorManipulator.private_safeLighten)(palette.success.main, 0.62));
+      setColor(palette.LinearProgress, "warningBg", (0, import_colorManipulator.private_safeLighten)(palette.warning.main, 0.62));
+      setColor(palette.Skeleton, "bg", `rgba(${setCssVarColor("palette-text-primaryChannel")} / 0.11)`);
+      setColor(palette.Slider, "primaryTrack", (0, import_colorManipulator.private_safeLighten)(palette.primary.main, 0.62));
+      setColor(palette.Slider, "secondaryTrack", (0, import_colorManipulator.private_safeLighten)(palette.secondary.main, 0.62));
+      setColor(palette.Slider, "errorTrack", (0, import_colorManipulator.private_safeLighten)(palette.error.main, 0.62));
+      setColor(palette.Slider, "infoTrack", (0, import_colorManipulator.private_safeLighten)(palette.info.main, 0.62));
+      setColor(palette.Slider, "successTrack", (0, import_colorManipulator.private_safeLighten)(palette.success.main, 0.62));
+      setColor(palette.Slider, "warningTrack", (0, import_colorManipulator.private_safeLighten)(palette.warning.main, 0.62));
+      const snackbarContentBackground = (0, import_colorManipulator.private_safeEmphasize)(palette.background.default, 0.8);
+      setColor(palette.SnackbarContent, "bg", snackbarContentBackground);
+      setColor(palette.SnackbarContent, "color", silent(() => lightPalette.getContrastText(snackbarContentBackground)));
+      setColor(palette.SpeedDialAction, "fabHoverBg", (0, import_colorManipulator.private_safeEmphasize)(palette.background.paper, 0.15));
+      setColor(palette.StepConnector, "border", setCssVarColor("palette-grey-400"));
+      setColor(palette.StepContent, "border", setCssVarColor("palette-grey-400"));
+      setColor(palette.Switch, "defaultColor", setCssVarColor("palette-common-white"));
+      setColor(palette.Switch, "defaultDisabledColor", setCssVarColor("palette-grey-100"));
+      setColor(palette.Switch, "primaryDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.primary.main, 0.62));
+      setColor(palette.Switch, "secondaryDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.secondary.main, 0.62));
+      setColor(palette.Switch, "errorDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.error.main, 0.62));
+      setColor(palette.Switch, "infoDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.info.main, 0.62));
+      setColor(palette.Switch, "successDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.success.main, 0.62));
+      setColor(palette.Switch, "warningDisabledColor", (0, import_colorManipulator.private_safeLighten)(palette.warning.main, 0.62));
+      setColor(palette.TableCell, "border", (0, import_colorManipulator.private_safeLighten)((0, import_colorManipulator.private_safeAlpha)(palette.divider, 1), 0.88));
+      setColor(palette.Tooltip, "bg", (0, import_colorManipulator.private_safeAlpha)(palette.grey[700], 0.92));
+    } else {
+      setColor(palette.Alert, "errorColor", (0, import_colorManipulator.private_safeLighten)(palette.error.light, 0.6));
+      setColor(palette.Alert, "infoColor", (0, import_colorManipulator.private_safeLighten)(palette.info.light, 0.6));
+      setColor(palette.Alert, "successColor", (0, import_colorManipulator.private_safeLighten)(palette.success.light, 0.6));
+      setColor(palette.Alert, "warningColor", (0, import_colorManipulator.private_safeLighten)(palette.warning.light, 0.6));
+      setColor(palette.Alert, "errorFilledBg", setCssVarColor("palette-error-dark"));
+      setColor(palette.Alert, "infoFilledBg", setCssVarColor("palette-info-dark"));
+      setColor(palette.Alert, "successFilledBg", setCssVarColor("palette-success-dark"));
+      setColor(palette.Alert, "warningFilledBg", setCssVarColor("palette-warning-dark"));
+      setColor(palette.Alert, "errorFilledColor", silent(() => darkPalette.getContrastText(palette.error.dark)));
+      setColor(palette.Alert, "infoFilledColor", silent(() => darkPalette.getContrastText(palette.info.dark)));
+      setColor(palette.Alert, "successFilledColor", silent(() => darkPalette.getContrastText(palette.success.dark)));
+      setColor(palette.Alert, "warningFilledColor", silent(() => darkPalette.getContrastText(palette.warning.dark)));
+      setColor(palette.Alert, "errorStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.error.light, 0.9));
+      setColor(palette.Alert, "infoStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.info.light, 0.9));
+      setColor(palette.Alert, "successStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.success.light, 0.9));
+      setColor(palette.Alert, "warningStandardBg", (0, import_colorManipulator.private_safeDarken)(palette.warning.light, 0.9));
+      setColor(palette.Alert, "errorIconColor", setCssVarColor("palette-error-main"));
+      setColor(palette.Alert, "infoIconColor", setCssVarColor("palette-info-main"));
+      setColor(palette.Alert, "successIconColor", setCssVarColor("palette-success-main"));
+      setColor(palette.Alert, "warningIconColor", setCssVarColor("palette-warning-main"));
+      setColor(palette.AppBar, "defaultBg", setCssVarColor("palette-grey-900"));
+      setColor(palette.AppBar, "darkBg", setCssVarColor("palette-background-paper"));
+      setColor(palette.AppBar, "darkColor", setCssVarColor("palette-text-primary"));
+      setColor(palette.Avatar, "defaultBg", setCssVarColor("palette-grey-600"));
+      setColor(palette.Button, "inheritContainedBg", setCssVarColor("palette-grey-800"));
+      setColor(palette.Button, "inheritContainedHoverBg", setCssVarColor("palette-grey-700"));
+      setColor(palette.Chip, "defaultBorder", setCssVarColor("palette-grey-700"));
+      setColor(palette.Chip, "defaultAvatarColor", setCssVarColor("palette-grey-300"));
+      setColor(palette.Chip, "defaultIconColor", setCssVarColor("palette-grey-300"));
+      setColor(palette.FilledInput, "bg", "rgba(255, 255, 255, 0.09)");
+      setColor(palette.FilledInput, "hoverBg", "rgba(255, 255, 255, 0.13)");
+      setColor(palette.FilledInput, "disabledBg", "rgba(255, 255, 255, 0.12)");
+      setColor(palette.LinearProgress, "primaryBg", (0, import_colorManipulator.private_safeDarken)(palette.primary.main, 0.5));
+      setColor(palette.LinearProgress, "secondaryBg", (0, import_colorManipulator.private_safeDarken)(palette.secondary.main, 0.5));
+      setColor(palette.LinearProgress, "errorBg", (0, import_colorManipulator.private_safeDarken)(palette.error.main, 0.5));
+      setColor(palette.LinearProgress, "infoBg", (0, import_colorManipulator.private_safeDarken)(palette.info.main, 0.5));
+      setColor(palette.LinearProgress, "successBg", (0, import_colorManipulator.private_safeDarken)(palette.success.main, 0.5));
+      setColor(palette.LinearProgress, "warningBg", (0, import_colorManipulator.private_safeDarken)(palette.warning.main, 0.5));
+      setColor(palette.Skeleton, "bg", `rgba(${setCssVarColor("palette-text-primaryChannel")} / 0.13)`);
+      setColor(palette.Slider, "primaryTrack", (0, import_colorManipulator.private_safeDarken)(palette.primary.main, 0.5));
+      setColor(palette.Slider, "secondaryTrack", (0, import_colorManipulator.private_safeDarken)(palette.secondary.main, 0.5));
+      setColor(palette.Slider, "errorTrack", (0, import_colorManipulator.private_safeDarken)(palette.error.main, 0.5));
+      setColor(palette.Slider, "infoTrack", (0, import_colorManipulator.private_safeDarken)(palette.info.main, 0.5));
+      setColor(palette.Slider, "successTrack", (0, import_colorManipulator.private_safeDarken)(palette.success.main, 0.5));
+      setColor(palette.Slider, "warningTrack", (0, import_colorManipulator.private_safeDarken)(palette.warning.main, 0.5));
+      const snackbarContentBackground = (0, import_colorManipulator.private_safeEmphasize)(palette.background.default, 0.98);
+      setColor(palette.SnackbarContent, "bg", snackbarContentBackground);
+      setColor(palette.SnackbarContent, "color", silent(() => darkPalette.getContrastText(snackbarContentBackground)));
+      setColor(palette.SpeedDialAction, "fabHoverBg", (0, import_colorManipulator.private_safeEmphasize)(palette.background.paper, 0.15));
+      setColor(palette.StepConnector, "border", setCssVarColor("palette-grey-600"));
+      setColor(palette.StepContent, "border", setCssVarColor("palette-grey-600"));
+      setColor(palette.Switch, "defaultColor", setCssVarColor("palette-grey-300"));
+      setColor(palette.Switch, "defaultDisabledColor", setCssVarColor("palette-grey-600"));
+      setColor(palette.Switch, "primaryDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.primary.main, 0.55));
+      setColor(palette.Switch, "secondaryDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.secondary.main, 0.55));
+      setColor(palette.Switch, "errorDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.error.main, 0.55));
+      setColor(palette.Switch, "infoDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.info.main, 0.55));
+      setColor(palette.Switch, "successDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.success.main, 0.55));
+      setColor(palette.Switch, "warningDisabledColor", (0, import_colorManipulator.private_safeDarken)(palette.warning.main, 0.55));
+      setColor(palette.TableCell, "border", (0, import_colorManipulator.private_safeDarken)((0, import_colorManipulator.private_safeAlpha)(palette.divider, 1), 0.68));
+      setColor(palette.Tooltip, "bg", (0, import_colorManipulator.private_safeAlpha)(palette.grey[700], 0.92));
+    }
+    setColorChannel(palette.background, "default");
+    setColorChannel(palette.background, "paper");
+    setColorChannel(palette.common, "background");
+    setColorChannel(palette.common, "onBackground");
+    setColorChannel(palette, "divider");
+    Object.keys(palette).forEach((color) => {
+      const colors = palette[color];
+      if (colors && typeof colors === "object") {
+        if (colors.main) {
+          setColor(palette[color], "mainChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.main)));
+        }
+        if (colors.light) {
+          setColor(palette[color], "lightChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.light)));
+        }
+        if (colors.dark) {
+          setColor(palette[color], "darkChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.dark)));
+        }
+        if (colors.contrastText) {
+          setColor(palette[color], "contrastTextChannel", (0, import_colorManipulator.private_safeColorChannel)(toRgb(colors.contrastText)));
+        }
+        if (color === "text") {
+          setColorChannel(palette[color], "primary");
+          setColorChannel(palette[color], "secondary");
+        }
+        if (color === "action") {
+          if (colors.active) {
+            setColorChannel(palette[color], "active");
+          }
+          if (colors.selected) {
+            setColorChannel(palette[color], "selected");
+          }
+        }
+      }
+    });
+  });
+  theme = args.reduce((acc, argument) => deepmerge(acc, argument), theme);
+  const parserConfig = {
+    prefix: cssVarPrefix,
+    shouldSkipGeneratingVar: shouldSkipGeneratingVar2
+  };
+  const {
+    vars: themeVars,
+    generateCssVars
+  } = prepareCssVars_default(theme, parserConfig);
+  theme.vars = themeVars;
+  theme.generateCssVars = generateCssVars;
+  theme.shouldSkipGeneratingVar = shouldSkipGeneratingVar2;
+  theme.unstable_sxConfig = _extends({}, defaultSxConfig_default, input == null ? void 0 : input.unstable_sxConfig);
+  theme.unstable_sx = function sx(props) {
+    return styleFunctionSx_default({
+      sx: props,
+      theme: this
+    });
+  };
+  return theme;
+}
+
+// node_modules/@mui/material/styles/excludeVariablesFromRoot.js
+var excludeVariablesFromRoot = (cssVarPrefix) => [...[...Array(24)].map((_, index) => `--${cssVarPrefix ? `${cssVarPrefix}-` : ""}overlays-${index + 1}`), `--${cssVarPrefix ? `${cssVarPrefix}-` : ""}palette-AppBar-darkBg`, `--${cssVarPrefix ? `${cssVarPrefix}-` : ""}palette-AppBar-darkColor`];
+var excludeVariablesFromRoot_default = excludeVariablesFromRoot;
+
+// node_modules/@mui/material/InitColorSchemeScript/InitColorSchemeScript.js
+init_extends();
+var React3 = __toESM(require_react());
+var import_jsx_runtime2 = __toESM(require_jsx_runtime());
+var defaultConfig = {
+  attribute: "data-mui-color-scheme",
+  colorSchemeStorageKey: "mui-color-scheme",
+  defaultLightColorScheme: "light",
+  defaultDarkColorScheme: "dark",
+  modeStorageKey: "mui-mode"
+};
+
+// node_modules/@mui/material/styles/CssVarsProvider.js
+var defaultTheme = extendTheme();
+var {
+  CssVarsProvider,
+  useColorScheme,
+  getInitColorSchemeScript: getInitColorSchemeScriptSystem
+} = createCssVarsProvider({
+  themeId: identifier_default,
+  theme: defaultTheme,
+  attribute: defaultConfig.attribute,
+  colorSchemeStorageKey: defaultConfig.colorSchemeStorageKey,
+  modeStorageKey: defaultConfig.modeStorageKey,
+  defaultColorScheme: {
+    light: defaultConfig.defaultLightColorScheme,
+    dark: defaultConfig.defaultDarkColorScheme
+  },
+  resolveTheme: (theme) => {
+    const newTheme = _extends({}, theme, {
+      typography: createTypography(theme.palette, theme.typography)
+    });
+    newTheme.unstable_sx = function sx(props) {
+      return styleFunctionSx_default({
+        sx: props,
+        theme: this
+      });
+    };
+    return newTheme;
+  },
+  excludeVariablesFromRoot: excludeVariablesFromRoot_default
+});
+var getInitColorSchemeScript = getInitColorSchemeScriptSystem;
+
+// node_modules/@mui/material/styles/index.js
+function experimental_sx() {
+  throw new Error(true ? `MUI: The \`experimental_sx\` has been moved to \`theme.unstable_sx\`.For more details, see https://github.com/mui/material-ui/pull/35150.` : formatMuiErrorMessage(20));
+}
+
+export {
+  adaptV4Theme,
+  createMuiStrictModeTheme,
+  createStyles,
+  getUnit,
+  toUnitless,
+  responsiveFontSizes,
+  useTheme,
+  useThemeProps2 as useThemeProps,
+  ThemeProvider,
+  makeStyles,
+  withStyles,
+  withTheme,
+  shouldSkipGeneratingVar,
+  getOverlayAlpha_default,
+  extendTheme,
+  excludeVariablesFromRoot_default,
+  CssVarsProvider,
+  useColorScheme,
+  getInitColorSchemeScript,
+  experimental_sx
+};
+//# sourceMappingURL=chunk-Y5IG6O7D.js.map

control-plane-ui/node_modules/.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

control-plane-ui/node_modules/.vite/deps/react-dom.js

@@ -0,0 +1,7 @@
+import {
+  require_react_dom
+} from "./chunk-UPELNCPK.js";
+import "./chunk-BG45W2ER.js";
+import "./chunk-HXA6O6EE.js";
+export default require_react_dom();
+//# sourceMappingURL=react-dom.js.map

control-plane-ui/node_modules/.vite/deps/react-dom.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

control-plane-ui/node_modules/.vite/deps/react-dom_client.js

@@ -0,0 +1,39 @@
+import {
+  require_react_dom
+} from "./chunk-UPELNCPK.js";
+import "./chunk-BG45W2ER.js";
+import {
+  __commonJS
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/react-dom/client.js
+var require_client = __commonJS({
+  "node_modules/react-dom/client.js"(exports) {
+    var m = require_react_dom();
+    if (false) {
+      exports.createRoot = m.createRoot;
+      exports.hydrateRoot = m.hydrateRoot;
+    } else {
+      i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      exports.createRoot = function(c, o) {
+        i.usingClientEntryPoint = true;
+        try {
+          return m.createRoot(c, o);
+        } finally {
+          i.usingClientEntryPoint = false;
+        }
+      };
+      exports.hydrateRoot = function(c, h, o) {
+        i.usingClientEntryPoint = true;
+        try {
+          return m.hydrateRoot(c, h, o);
+        } finally {
+          i.usingClientEntryPoint = false;
+        }
+      };
+    }
+    var i;
+  }
+});
+export default require_client();
+//# sourceMappingURL=react-dom_client.js.map

control-plane-ui/node_modules/.vite/deps/react-dom_client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../react-dom/client.js"],
+  "sourcesContent": ["'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n"],
+  "mappings": ";;;;;;;;;AAAA;AAAA;AAEA,QAAI,IAAI;AACR,QAAI,OAAuC;AACzC,cAAQ,aAAa,EAAE;AACvB,cAAQ,cAAc,EAAE;AAAA,IAC1B,OAAO;AACD,UAAI,EAAE;AACV,cAAQ,aAAa,SAAS,GAAG,GAAG;AAClC,UAAE,wBAAwB;AAC1B,YAAI;AACF,iBAAO,EAAE,WAAW,GAAG,CAAC;AAAA,QAC1B,UAAE;AACA,YAAE,wBAAwB;AAAA,QAC5B;AAAA,MACF;AACA,cAAQ,cAAc,SAAS,GAAG,GAAG,GAAG;AACtC,UAAE,wBAAwB;AAC1B,YAAI;AACF,iBAAO,EAAE,YAAY,GAAG,GAAG,CAAC;AAAA,QAC9B,UAAE;AACA,YAAE,wBAAwB;AAAA,QAC5B;AAAA,MACF;AAAA,IACF;AAjBM;AAAA;AAAA;",
+  "names": []
+}

control-plane-ui/node_modules/.vite/deps/react.js

@@ -0,0 +1,6 @@
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import "./chunk-HXA6O6EE.js";
+export default require_react();
+//# sourceMappingURL=react.js.map

control-plane-ui/node_modules/.vite/deps/react.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

control-plane-ui/node_modules/.vite/deps/react_jsx-dev-runtime.js

@@ -0,0 +1,913 @@
+import {
+  require_react
+} from "./chunk-BG45W2ER.js";
+import {
+  __commonJS
+} from "./chunk-HXA6O6EE.js";
+
+// node_modules/react/cjs/react-jsx-dev-runtime.development.js
+var require_react_jsx_dev_runtime_development = __commonJS({
+  "node_modules/react/cjs/react-jsx-dev-runtime.development.js"(exports) {
+    "use strict";
+    if (true) {
+      (function() {
+        "use strict";
+        var React = require_react();
+        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) {
+          {
+            var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
+            var stack = ReactDebugCurrentFrame2.getStackAddendum();
+            if (stack !== "") {
+              format += "%s";
+              args = args.concat([stack]);
+            }
+            var argsWithFormat = args.map(function(item) {
+              return String(item);
+            });
+            argsWithFormat.unshift("Warning: " + format);
+            Function.prototype.apply.call(console[level], console, argsWithFormat);
+          }
+        }
+        var enableScopeAPI = false;
+        var enableCacheElement = false;
+        var enableTransitionTracing = false;
+        var enableLegacyHidden = false;
+        var enableDebugTracing = false;
+        var REACT_MODULE_REFERENCE;
+        {
+          REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
+        }
+        function isValidElementType(type) {
+          if (typeof type === "string" || typeof type === "function") {
+            return true;
+          }
+          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 !== void 0) {
+              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;
+        }
+        function getContextName(type) {
+          return type.displayName || "Context";
+        }
+        function getComponentNameFromType(type) {
+          if (type == null) {
+            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;
+                }
+              }
+            }
+          }
+          return null;
+        }
+        var assign = Object.assign;
+        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) {
+              prevLog = console.log;
+              prevInfo = console.info;
+              prevWarn = console.warn;
+              prevError = console.error;
+              prevGroup = console.group;
+              prevGroupCollapsed = console.groupCollapsed;
+              prevGroupEnd = console.groupEnd;
+              var props = {
+                configurable: true,
+                enumerable: true,
+                value: disabledLog,
+                writable: true
+              };
+              Object.defineProperties(console, {
+                info: props,
+                log: props,
+                warn: props,
+                error: props,
+                group: props,
+                groupCollapsed: props,
+                groupEnd: props
+              });
+            }
+            disabledDepth++;
+          }
+        }
+        function reenableLogs() {
+          {
+            disabledDepth--;
+            if (disabledDepth === 0) {
+              var props = {
+                configurable: true,
+                enumerable: true,
+                writable: true
+              };
+              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
+                })
+              });
+            }
+            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 === void 0) {
+              try {
+                throw Error();
+              } catch (x) {
+                var match = x.stack.trim().match(/\n( *(at )?)/);
+                prefix = match && match[1] || "";
+              }
+            }
+            return "\n" + prefix + name;
+          }
+        }
+        var reentry = false;
+        var componentFrameCache;
+        {
+          var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+          componentFrameCache = new PossiblyWeakMap();
+        }
+        function describeNativeComponentFrame(fn, construct) {
+          if (!fn || reentry) {
+            return "";
+          }
+          {
+            var frame = componentFrameCache.get(fn);
+            if (frame !== void 0) {
+              return frame;
+            }
+          }
+          var control;
+          reentry = true;
+          var previousPrepareStackTrace = Error.prepareStackTrace;
+          Error.prepareStackTrace = void 0;
+          var previousDispatcher;
+          {
+            previousDispatcher = ReactCurrentDispatcher.current;
+            ReactCurrentDispatcher.current = null;
+            disableLogs();
+          }
+          try {
+            if (construct) {
+              var Fake = function() {
+                throw Error();
+              };
+              Object.defineProperty(Fake.prototype, "props", {
+                set: function() {
+                  throw Error();
+                }
+              });
+              if (typeof Reflect === "object" && Reflect.construct) {
+                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) {
+            if (sample && control && typeof sample.stack === "string") {
+              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]) {
+                c--;
+              }
+              for (; s >= 1 && c >= 0; s--, c--) {
+                if (sampleLines[s] !== controlLines[c]) {
+                  if (s !== 1 || c !== 1) {
+                    do {
+                      s--;
+                      c--;
+                      if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                        var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
+                        if (fn.displayName && _frame.includes("<anonymous>")) {
+                          _frame = _frame.replace("<anonymous>", fn.displayName);
+                        }
+                        {
+                          if (typeof fn === "function") {
+                            componentFrameCache.set(fn, _frame);
+                          }
+                        }
+                        return _frame;
+                      }
+                    } while (s >= 1 && c >= 0);
+                  }
+                  break;
+                }
+              }
+            }
+          } finally {
+            reentry = false;
+            {
+              ReactCurrentDispatcher.current = previousDispatcher;
+              reenableLogs();
+            }
+            Error.prepareStackTrace = previousPrepareStackTrace;
+          }
+          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:
+                return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+              case REACT_LAZY_TYPE: {
+                var lazyComponent = type;
+                var payload = lazyComponent._payload;
+                var init = lazyComponent._init;
+                try {
+                  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) {
+          {
+            var has = Function.call.bind(hasOwnProperty);
+            for (var typeSpecName in typeSpecs) {
+              if (has(typeSpecs, typeSpecName)) {
+                var error$1 = void 0;
+                try {
+                  if (typeof typeSpecs[typeSpecName] !== "function") {
+                    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)) {
+                  loggedTypeFailures[error$1.message] = true;
+                  setCurrentlyValidatingElement(element);
+                  error("Failed %s type: %s", location, error$1.message);
+                  setCurrentlyValidatingElement(null);
+                }
+              }
+            }
+          }
+        }
+        var isArrayImpl = Array.isArray;
+        function isArray(a) {
+          return isArrayImpl(a);
+        }
+        function typeName(value) {
+          {
+            var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
+            var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+            return type;
+          }
+        }
+        function willCoercionThrow(value) {
+          {
+            try {
+              testStringCoercion(value);
+              return false;
+            } catch (e) {
+              return true;
+            }
+          }
+        }
+        function testStringCoercion(value) {
+          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);
+            }
+          }
+        }
+        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 !== void 0;
+        }
+        function hasValidKey(config) {
+          {
+            if (hasOwnProperty.call(config, "key")) {
+              var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+              if (getter && getter.isReactWarning) {
+                return false;
+              }
+            }
+          }
+          return config.key !== void 0;
+        }
+        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
+            });
+          }
+        }
+        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,
+            key,
+            ref,
+            props,
+            // Record the component responsible for creating this element.
+            _owner: owner
+          };
+          {
+            element._store = {};
+            Object.defineProperty(element._store, "validated", {
+              configurable: false,
+              enumerable: false,
+              writable: true,
+              value: false
+            });
+            Object.defineProperty(element, "_self", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: self
+            });
+            Object.defineProperty(element, "_source", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: source
+            });
+            if (Object.freeze) {
+              Object.freeze(element.props);
+              Object.freeze(element);
+            }
+          }
+          return element;
+        };
+        function jsxDEV(type, config, maybeKey, source, self) {
+          {
+            var propName;
+            var props = {};
+            var key = null;
+            var ref = null;
+            if (maybeKey !== void 0) {
+              {
+                checkKeyStringCoercion(maybeKey);
+              }
+              key = "" + maybeKey;
+            }
+            if (hasValidKey(config)) {
+              {
+                checkKeyStringCoercion(config.key);
+              }
+              key = "" + config.key;
+            }
+            if (hasValidRef(config)) {
+              ref = config.ref;
+              warnIfStringRefCannotBeAutoConverted(config, self);
+            }
+            for (propName in config) {
+              if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                props[propName] = config[propName];
+              }
+            }
+            if (type && type.defaultProps) {
+              var defaultProps = type.defaultProps;
+              for (propName in defaultProps) {
+                if (props[propName] === void 0) {
+                  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;
+        }
+        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 !== void 0) {
+              var fileName = source.fileName.replace(/^.*[\\\/]/, "");
+              var lineNumber = source.lineNumber;
+              return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
+            }
+            return "";
+          }
+        }
+        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;
+          }
+        }
+        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;
+            var childOwner = "";
+            if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
+              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);
+          }
+        }
+        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)) {
+              if (node._store) {
+                node._store.validated = true;
+              }
+            } else if (node) {
+              var iteratorFn = getIteratorFn(node);
+              if (typeof iteratorFn === "function") {
+                if (iteratorFn !== node.entries) {
+                  var iterator = iteratorFn.call(node);
+                  var step;
+                  while (!(step = iterator.next()).done) {
+                    if (isValidElement(step.value)) {
+                      validateExplicitKey(step.value, parentType);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        function validatePropTypes(element) {
+          {
+            var type = element.type;
+            if (type === null || type === void 0 || 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) {
+              var name = getComponentNameFromType(type);
+              checkPropTypes(propTypes, element.props, "prop", name, element);
+            } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
+              propTypesMisspellWarningShown = true;
+              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.");
+            }
+          }
+        }
+        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);
+            }
+          }
+        }
+        var didWarnAboutKeySpread = {};
+        function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
+          {
+            var validType = isValidElementType(type);
+            if (!validType) {
+              var info = "";
+              if (type === void 0 || 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 !== void 0 && 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);
+            if (element == null) {
+              return element;
+            }
+            if (validType) {
+              var children = props.children;
+              if (children !== void 0) {
+                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 (hasOwnProperty.call(props, "key")) {
+                var componentName = getComponentNameFromType(type);
+                var keys = Object.keys(props).filter(function(k) {
+                  return k !== "key";
+                });
+                var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+                if (!didWarnAboutKeySpread[componentName + beforeExample]) {
+                  var afterExample = keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}";
+                  error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);
+                  didWarnAboutKeySpread[componentName + beforeExample] = true;
+                }
+              }
+            }
+            if (type === REACT_FRAGMENT_TYPE) {
+              validateFragmentProps(element);
+            } else {
+              validatePropTypes(element);
+            }
+            return element;
+          }
+        }
+        var jsxDEV$1 = jsxWithValidation;
+        exports.Fragment = REACT_FRAGMENT_TYPE;
+        exports.jsxDEV = jsxDEV$1;
+      })();
+    }
+  }
+});
+
+// node_modules/react/jsx-dev-runtime.js
+var require_jsx_dev_runtime = __commonJS({
+  "node_modules/react/jsx-dev-runtime.js"(exports, module) {
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_jsx_dev_runtime_development();
+    }
+  }
+});
+export default require_jsx_dev_runtime();
+/*! Bundled license information:
+
+react/cjs/react-jsx-dev-runtime.development.js:
+  (**
+   * @license React
+   * react-jsx-dev-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.
+   *)
+*/
+//# sourceMappingURL=react_jsx-dev-runtime.js.map

control-plane-ui/node_modules/.vite/deps/react_jsx-runtime.js

@@ -0,0 +1,7 @@
+import {
+  require_jsx_runtime
+} from "./chunk-WKPQ4ZTV.js";
+import "./chunk-BG45W2ER.js";
+import "./chunk-HXA6O6EE.js";
+export default require_jsx_runtime();
+//# sourceMappingURL=react_jsx-runtime.js.map

control-plane-ui/node_modules/.vite/deps/react_jsx-runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

control-plane-ui/node_modules/.vite/vitest/results.json

@@ -0,0 +1 @@
+{"version":"1.6.1","results":[[":src/tests/Layout.test.tsx",{"duration":3144,"failed":false}],[":src/tests/api.test.ts",{"duration":4,"failed":false}],[":tests/integration/generate_keys.test.ts",{"duration":3,"failed":false}],[":tests/integration/scaling.test.tsx",{"duration":533,"failed":false}],[":tests/integration/servers.test.tsx",{"duration":3305,"failed":false}],[":tests/integration/templates.test.tsx",{"duration":488,"failed":false}],[":tests/integration/dashboard.test.tsx",{"duration":3020,"failed":false}]]}

control-plane-ui/node_modules/@adobe/css-tools/LICENSE

@@ -0,0 +1,10 @@
+(The MIT License)
+
+Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2022 Jean-Philippe Zolesio <holblin@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

control-plane-ui/node_modules/@adobe/css-tools/README.md

@@ -0,0 +1,146 @@
+# @adobe/css-tools
+
+> A modern CSS parser and stringifier with TypeScript support
+
+[![npm version](https://badge.fury.io/js/%40adobe%2Fcss-tools.svg)](https://badge.fury.io/js/%40adobe%2Fcss-tools)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Parse CSS into an Abstract Syntax Tree (AST) and convert it back to CSS with configurable formatting. Built with TypeScript for type safety and modern JavaScript features.
+
+## Install
+
+```bash
+npm install @adobe/css-tools
+```
+
+## Usage
+
+```js
+import { parse, stringify } from '@adobe/css-tools'
+
+// Parse CSS to AST
+const ast = parse('body { font-size: 12px; }')
+
+// Stringify AST back to CSS
+const css = stringify(ast)
+// => "body { font-size: 12px; }"
+
+// Pretty print with custom indentation
+const formatted = stringify(ast, { indent: '  ' })
+// => "body {\n  font-size: 12px;\n}"
+
+// Minify output
+const minified = stringify(ast, { compress: true })
+// => "body{font-size:12px}"
+```
+
+## API
+
+### `parse(code, options?)`
+
+Parses CSS code and returns an Abstract Syntax Tree (AST).
+
+**Parameters:**
+- `code` (string) - The CSS code to parse
+- `options` (object, optional) - Parsing options
+  - `silent` (boolean) - Silently fail on parse errors instead of throwing
+  - `source` (string) - File path for better error reporting
+
+**Returns:** `CssStylesheetAST` - The parsed CSS as an AST
+
+### `stringify(ast, options?)`
+
+Converts a CSS AST back to CSS string with configurable formatting.
+
+**Parameters:**
+- `ast` (CssStylesheetAST) - The CSS AST to stringify
+- `options` (object, optional) - Stringification options
+  - `indent` (string) - Indentation string (default: `'  '`)
+  - `compress` (boolean) - Whether to compress/minify the output (default: `false`)
+
+**Returns:** `string` - The formatted CSS string
+
+## Features
+
+- **Complete CSS Support**: All standard CSS features including selectors, properties, values, at-rules, and comments
+- **TypeScript Support**: Full type definitions for all AST nodes and functions
+- **Error Handling**: Configurable error handling with detailed position information
+- **Formatting Options**: Pretty print, minify, or custom formatting
+- **Performance Optimized**: Efficient parsing and stringification for large CSS files
+- **Source Maps**: Track original source positions for debugging and tooling
+
+### Supported CSS Features
+
+- **Selectors**: Element, class, ID, attribute, pseudo-class, pseudo-element selectors
+- **Properties**: All standard CSS properties and custom properties
+- **Values**: Colors, lengths, percentages, functions, calc(), etc.
+- **At-rules**: @media, @keyframes, @import, @charset, @namespace, @font-face, @page, @document, @supports, @container, @layer, @starting-style, @host, @custom-media
+- **Comments**: Both /* */ and // comments
+- **Whitespace**: Preserves formatting information
+- **Vendor prefixes**: Supports vendor-prefixed at-rules and properties
+- **Nested rules**: Media queries, supports, containers, etc.
+- **Complex selectors**: Combinators, pseudo-selectors, attribute selectors
+
+## Examples
+
+### Error Handling
+
+```js
+import { parse } from '@adobe/css-tools'
+
+const malformedCss = `
+  body { color: red; }
+  { color: blue; } /* Missing selector */
+  .valid { background: green; }
+`
+
+// Parse with silent error handling
+const result = parse(malformedCss, { silent: true })
+
+// Check for parsing errors
+if (result.stylesheet.parsingErrors) {
+  console.log('Parsing errors:', result.stylesheet.parsingErrors.length)
+  result.stylesheet.parsingErrors.forEach(error => {
+    console.log(`Error at line ${error.line}: ${error.message}`)
+  })
+}
+
+// Valid rules are still parsed
+console.log('Valid rules:', result.stylesheet.rules.length)
+```
+
+### Source Tracking
+
+```js
+import { parse } from '@adobe/css-tools'
+
+const css = 'body { color: red; }'
+const ast = parse(css, { source: 'styles.css' })
+
+// Position information is available
+const rule = ast.stylesheet.rules[0]
+console.log(rule.position?.source) // "styles.css"
+console.log(rule.position?.start) // { line: 1, column: 1 }
+console.log(rule.position?.end) // { line: 1, column: 20 }
+```
+
+For more examples, see the [Examples documentation](docs/EXAMPLES.md).
+
+## Performance
+
+The library is optimized for performance and can handle large CSS files efficiently. For benchmarking information, see the `benchmark/` directory in the source code.
+
+## Documentation
+
+- [API Reference](docs/API.md) - Complete API documentation
+- [AST Structure](docs/AST.md) - Detailed AST node types and structure
+- [Examples](docs/EXAMPLES.md) - Comprehensive usage examples
+- [Changelog](docs/CHANGELOG.md) - Version history and changes
+
+## Background
+
+This is a fork of the npm `css` package, maintained by Adobe with modern improvements including TypeScript support, enhanced performance, and security updates. It provides a robust foundation for CSS tooling, preprocessing, and analysis.
+
+## License
+
+[MIT](LICENSE)

control-plane-ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.d.cts

@@ -0,0 +1,176 @@
+declare class CssParseError extends Error {
+    readonly reason: string;
+    readonly filename?: string;
+    readonly line: number;
+    readonly column: number;
+    readonly source: string;
+    constructor(filename: string, msg: string, lineno: number, column: number, css: string);
+}
+
+/**
+ * Store position information for a node
+ */
+declare class Position {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+    source?: string;
+    constructor(start: {
+        line: number;
+        column: number;
+    }, end: {
+        line: number;
+        column: number;
+    }, source: string);
+}
+
+declare enum CssTypes {
+    stylesheet = "stylesheet",
+    rule = "rule",
+    declaration = "declaration",
+    comment = "comment",
+    container = "container",
+    charset = "charset",
+    document = "document",
+    customMedia = "custom-media",
+    fontFace = "font-face",
+    host = "host",
+    import = "import",
+    keyframes = "keyframes",
+    keyframe = "keyframe",
+    layer = "layer",
+    media = "media",
+    namespace = "namespace",
+    page = "page",
+    startingStyle = "starting-style",
+    supports = "supports"
+}
+type CssCommonAST = {
+    type: CssTypes;
+};
+type CssCommonPositionAST = CssCommonAST & {
+    position?: Position;
+    parent?: unknown;
+};
+type CssStylesheetAST = CssCommonAST & {
+    type: CssTypes.stylesheet;
+    stylesheet: {
+        source?: string;
+        rules: Array<CssAtRuleAST>;
+        parsingErrors?: Array<CssParseError>;
+    };
+};
+type CssRuleAST = CssCommonPositionAST & {
+    type: CssTypes.rule;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssDeclarationAST = CssCommonPositionAST & {
+    type: CssTypes.declaration;
+    property: string;
+    value: string;
+};
+type CssCommentAST = CssCommonPositionAST & {
+    type: CssTypes.comment;
+    comment: string;
+};
+type CssContainerAST = CssCommonPositionAST & {
+    type: CssTypes.container;
+    container: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssCharsetAST = CssCommonPositionAST & {
+    type: CssTypes.charset;
+    charset: string;
+};
+type CssCustomMediaAST = CssCommonPositionAST & {
+    type: CssTypes.customMedia;
+    name: string;
+    media: string;
+};
+type CssDocumentAST = CssCommonPositionAST & {
+    type: CssTypes.document;
+    document: string;
+    vendor?: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssFontFaceAST = CssCommonPositionAST & {
+    type: CssTypes.fontFace;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssHostAST = CssCommonPositionAST & {
+    type: CssTypes.host;
+    rules: Array<CssAtRuleAST>;
+};
+type CssImportAST = CssCommonPositionAST & {
+    type: CssTypes.import;
+    import: string;
+};
+type CssKeyframesAST = CssCommonPositionAST & {
+    type: CssTypes.keyframes;
+    name: string;
+    vendor?: string;
+    keyframes: Array<CssKeyframeAST | CssCommentAST>;
+};
+type CssKeyframeAST = CssCommonPositionAST & {
+    type: CssTypes.keyframe;
+    values: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssLayerAST = CssCommonPositionAST & {
+    type: CssTypes.layer;
+    layer: string;
+    rules?: Array<CssAtRuleAST>;
+};
+type CssMediaAST = CssCommonPositionAST & {
+    type: CssTypes.media;
+    media: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssNamespaceAST = CssCommonPositionAST & {
+    type: CssTypes.namespace;
+    namespace: string;
+};
+type CssPageAST = CssCommonPositionAST & {
+    type: CssTypes.page;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssSupportsAST = CssCommonPositionAST & {
+    type: CssTypes.supports;
+    supports: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssStartingStyleAST = CssCommonPositionAST & {
+    type: CssTypes.startingStyle;
+    rules: Array<CssAtRuleAST>;
+};
+type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssSupportsAST | CssStartingStyleAST;
+type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST;
+
+type CompilerOptions = {
+    indent?: string;
+    compress?: boolean;
+};
+
+declare const parse: (css: string, options?: {
+    source?: string;
+    silent?: boolean;
+}) => CssStylesheetAST;
+declare const stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+
+declare const _default: {
+    parse: (css: string, options?: {
+        source?: string;
+        silent?: boolean;
+    }) => CssStylesheetAST;
+    stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+};
+
+export { CssTypes, _default as default, parse, stringify };
+export type { CssAllNodesAST, CssAtRuleAST, CssCharsetAST, CssCommentAST, CssCommonAST, CssCommonPositionAST, CssContainerAST, CssCustomMediaAST, CssDeclarationAST, CssDocumentAST, CssFontFaceAST, CssHostAST, CssImportAST, CssKeyframeAST, CssKeyframesAST, CssLayerAST, CssMediaAST, CssNamespaceAST, CssPageAST, CssRuleAST, CssStartingStyleAST, CssStylesheetAST, CssSupportsAST };

control-plane-ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.d.mts

@@ -0,0 +1,176 @@
+declare class CssParseError extends Error {
+    readonly reason: string;
+    readonly filename?: string;
+    readonly line: number;
+    readonly column: number;
+    readonly source: string;
+    constructor(filename: string, msg: string, lineno: number, column: number, css: string);
+}
+
+/**
+ * Store position information for a node
+ */
+declare class Position {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+    source?: string;
+    constructor(start: {
+        line: number;
+        column: number;
+    }, end: {
+        line: number;
+        column: number;
+    }, source: string);
+}
+
+declare enum CssTypes {
+    stylesheet = "stylesheet",
+    rule = "rule",
+    declaration = "declaration",
+    comment = "comment",
+    container = "container",
+    charset = "charset",
+    document = "document",
+    customMedia = "custom-media",
+    fontFace = "font-face",
+    host = "host",
+    import = "import",
+    keyframes = "keyframes",
+    keyframe = "keyframe",
+    layer = "layer",
+    media = "media",
+    namespace = "namespace",
+    page = "page",
+    startingStyle = "starting-style",
+    supports = "supports"
+}
+type CssCommonAST = {
+    type: CssTypes;
+};
+type CssCommonPositionAST = CssCommonAST & {
+    position?: Position;
+    parent?: unknown;
+};
+type CssStylesheetAST = CssCommonAST & {
+    type: CssTypes.stylesheet;
+    stylesheet: {
+        source?: string;
+        rules: Array<CssAtRuleAST>;
+        parsingErrors?: Array<CssParseError>;
+    };
+};
+type CssRuleAST = CssCommonPositionAST & {
+    type: CssTypes.rule;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssDeclarationAST = CssCommonPositionAST & {
+    type: CssTypes.declaration;
+    property: string;
+    value: string;
+};
+type CssCommentAST = CssCommonPositionAST & {
+    type: CssTypes.comment;
+    comment: string;
+};
+type CssContainerAST = CssCommonPositionAST & {
+    type: CssTypes.container;
+    container: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssCharsetAST = CssCommonPositionAST & {
+    type: CssTypes.charset;
+    charset: string;
+};
+type CssCustomMediaAST = CssCommonPositionAST & {
+    type: CssTypes.customMedia;
+    name: string;
+    media: string;
+};
+type CssDocumentAST = CssCommonPositionAST & {
+    type: CssTypes.document;
+    document: string;
+    vendor?: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssFontFaceAST = CssCommonPositionAST & {
+    type: CssTypes.fontFace;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssHostAST = CssCommonPositionAST & {
+    type: CssTypes.host;
+    rules: Array<CssAtRuleAST>;
+};
+type CssImportAST = CssCommonPositionAST & {
+    type: CssTypes.import;
+    import: string;
+};
+type CssKeyframesAST = CssCommonPositionAST & {
+    type: CssTypes.keyframes;
+    name: string;
+    vendor?: string;
+    keyframes: Array<CssKeyframeAST | CssCommentAST>;
+};
+type CssKeyframeAST = CssCommonPositionAST & {
+    type: CssTypes.keyframe;
+    values: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssLayerAST = CssCommonPositionAST & {
+    type: CssTypes.layer;
+    layer: string;
+    rules?: Array<CssAtRuleAST>;
+};
+type CssMediaAST = CssCommonPositionAST & {
+    type: CssTypes.media;
+    media: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssNamespaceAST = CssCommonPositionAST & {
+    type: CssTypes.namespace;
+    namespace: string;
+};
+type CssPageAST = CssCommonPositionAST & {
+    type: CssTypes.page;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssSupportsAST = CssCommonPositionAST & {
+    type: CssTypes.supports;
+    supports: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssStartingStyleAST = CssCommonPositionAST & {
+    type: CssTypes.startingStyle;
+    rules: Array<CssAtRuleAST>;
+};
+type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssSupportsAST | CssStartingStyleAST;
+type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST;
+
+type CompilerOptions = {
+    indent?: string;
+    compress?: boolean;
+};
+
+declare const parse: (css: string, options?: {
+    source?: string;
+    silent?: boolean;
+}) => CssStylesheetAST;
+declare const stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+
+declare const _default: {
+    parse: (css: string, options?: {
+        source?: string;
+        silent?: boolean;
+    }) => CssStylesheetAST;
+    stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+};
+
+export { CssTypes, _default as default, parse, stringify };
+export type { CssAllNodesAST, CssAtRuleAST, CssCharsetAST, CssCommentAST, CssCommonAST, CssCommonPositionAST, CssContainerAST, CssCustomMediaAST, CssDeclarationAST, CssDocumentAST, CssFontFaceAST, CssHostAST, CssImportAST, CssKeyframeAST, CssKeyframesAST, CssLayerAST, CssMediaAST, CssNamespaceAST, CssPageAST, CssRuleAST, CssStartingStyleAST, CssStylesheetAST, CssSupportsAST };

control-plane-ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.d.ts

@@ -0,0 +1,176 @@
+declare class CssParseError extends Error {
+    readonly reason: string;
+    readonly filename?: string;
+    readonly line: number;
+    readonly column: number;
+    readonly source: string;
+    constructor(filename: string, msg: string, lineno: number, column: number, css: string);
+}
+
+/**
+ * Store position information for a node
+ */
+declare class Position {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+    source?: string;
+    constructor(start: {
+        line: number;
+        column: number;
+    }, end: {
+        line: number;
+        column: number;
+    }, source: string);
+}
+
+declare enum CssTypes {
+    stylesheet = "stylesheet",
+    rule = "rule",
+    declaration = "declaration",
+    comment = "comment",
+    container = "container",
+    charset = "charset",
+    document = "document",
+    customMedia = "custom-media",
+    fontFace = "font-face",
+    host = "host",
+    import = "import",
+    keyframes = "keyframes",
+    keyframe = "keyframe",
+    layer = "layer",
+    media = "media",
+    namespace = "namespace",
+    page = "page",
+    startingStyle = "starting-style",
+    supports = "supports"
+}
+type CssCommonAST = {
+    type: CssTypes;
+};
+type CssCommonPositionAST = CssCommonAST & {
+    position?: Position;
+    parent?: unknown;
+};
+type CssStylesheetAST = CssCommonAST & {
+    type: CssTypes.stylesheet;
+    stylesheet: {
+        source?: string;
+        rules: Array<CssAtRuleAST>;
+        parsingErrors?: Array<CssParseError>;
+    };
+};
+type CssRuleAST = CssCommonPositionAST & {
+    type: CssTypes.rule;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssDeclarationAST = CssCommonPositionAST & {
+    type: CssTypes.declaration;
+    property: string;
+    value: string;
+};
+type CssCommentAST = CssCommonPositionAST & {
+    type: CssTypes.comment;
+    comment: string;
+};
+type CssContainerAST = CssCommonPositionAST & {
+    type: CssTypes.container;
+    container: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssCharsetAST = CssCommonPositionAST & {
+    type: CssTypes.charset;
+    charset: string;
+};
+type CssCustomMediaAST = CssCommonPositionAST & {
+    type: CssTypes.customMedia;
+    name: string;
+    media: string;
+};
+type CssDocumentAST = CssCommonPositionAST & {
+    type: CssTypes.document;
+    document: string;
+    vendor?: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssFontFaceAST = CssCommonPositionAST & {
+    type: CssTypes.fontFace;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssHostAST = CssCommonPositionAST & {
+    type: CssTypes.host;
+    rules: Array<CssAtRuleAST>;
+};
+type CssImportAST = CssCommonPositionAST & {
+    type: CssTypes.import;
+    import: string;
+};
+type CssKeyframesAST = CssCommonPositionAST & {
+    type: CssTypes.keyframes;
+    name: string;
+    vendor?: string;
+    keyframes: Array<CssKeyframeAST | CssCommentAST>;
+};
+type CssKeyframeAST = CssCommonPositionAST & {
+    type: CssTypes.keyframe;
+    values: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssLayerAST = CssCommonPositionAST & {
+    type: CssTypes.layer;
+    layer: string;
+    rules?: Array<CssAtRuleAST>;
+};
+type CssMediaAST = CssCommonPositionAST & {
+    type: CssTypes.media;
+    media: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssNamespaceAST = CssCommonPositionAST & {
+    type: CssTypes.namespace;
+    namespace: string;
+};
+type CssPageAST = CssCommonPositionAST & {
+    type: CssTypes.page;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST>;
+};
+type CssSupportsAST = CssCommonPositionAST & {
+    type: CssTypes.supports;
+    supports: string;
+    rules: Array<CssAtRuleAST>;
+};
+type CssStartingStyleAST = CssCommonPositionAST & {
+    type: CssTypes.startingStyle;
+    rules: Array<CssAtRuleAST>;
+};
+type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssSupportsAST | CssStartingStyleAST;
+type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST;
+
+type CompilerOptions = {
+    indent?: string;
+    compress?: boolean;
+};
+
+declare const parse: (css: string, options?: {
+    source?: string;
+    silent?: boolean;
+}) => CssStylesheetAST;
+declare const stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+
+declare const _default: {
+    parse: (css: string, options?: {
+        source?: string;
+        silent?: boolean;
+    }) => CssStylesheetAST;
+    stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+};
+
+export { CssTypes, _default as default, parse, stringify };
+export type { CssAllNodesAST, CssAtRuleAST, CssCharsetAST, CssCommentAST, CssCommonAST, CssCommonPositionAST, CssContainerAST, CssCustomMediaAST, CssDeclarationAST, CssDocumentAST, CssFontFaceAST, CssHostAST, CssImportAST, CssKeyframeAST, CssKeyframesAST, CssLayerAST, CssMediaAST, CssNamespaceAST, CssPageAST, CssRuleAST, CssStartingStyleAST, CssStylesheetAST, CssSupportsAST };

control-plane-ui/node_modules/@adobe/css-tools/docs/API.md

@@ -0,0 +1,314 @@
+# API Reference
+
+## Overview
+
+`@adobe/css-tools` provides a modern CSS parser and stringifier with comprehensive TypeScript support. It can parse CSS into an Abstract Syntax Tree (AST) and convert the AST back to CSS with various formatting options.
+
+## Installation
+
+```bash
+npm install @adobe/css-tools
+```
+
+## Core Functions
+
+### `parse(code, options?)`
+
+Parses CSS code and returns an Abstract Syntax Tree (AST).
+
+#### Parameters
+
+- `code` (string) - The CSS code to parse
+- `options` (object, optional) - Parsing options
+  - `silent` (boolean) - Silently fail on parse errors instead of throwing. When `true`, errors are collected in `ast.stylesheet.parsingErrors`
+  - `source` (string) - File path for better error reporting
+
+#### Returns
+
+- `CssStylesheetAST` - The parsed CSS as an AST
+
+#### Example
+
+```javascript
+import { parse } from '@adobe/css-tools';
+
+const css = `
+  .example {
+    color: red;
+    font-size: 16px;
+  }
+`;
+
+const ast = parse(css);
+console.log(ast.stylesheet.rules);
+```
+
+### `stringify(ast, options?)`
+
+Converts a CSS AST back to CSS string with configurable formatting.
+
+#### Parameters
+
+- `ast` (CssStylesheetAST) - The CSS AST to stringify
+- `options` (CompilerOptions, optional) - Stringification options
+  - `indent` (string) - Indentation string (default: `'  '`)
+  - `compress` (boolean) - Whether to compress/minify the output (default: `false`)
+
+#### Returns
+
+- `string` - The formatted CSS string
+
+#### Example
+
+```javascript
+import { parse, stringify } from '@adobe/css-tools';
+
+const css = '.example { color: red; }';
+const ast = parse(css);
+
+// Pretty print
+const formatted = stringify(ast, { indent: '  ' });
+console.log(formatted);
+// Output:
+// .example {
+//   color: red;
+// }
+
+// Compressed
+const minified = stringify(ast, { compress: true });
+console.log(minified);
+// Output: .example{color:red}
+```
+
+## Type Definitions
+
+### Core Types
+
+#### `CssStylesheetAST`
+The root AST node representing a complete CSS stylesheet.
+
+```typescript
+type CssStylesheetAST = {
+  type: CssTypes.stylesheet;
+  stylesheet: {
+    source?: string;
+    rules: CssRuleAST[];
+    parsingErrors?: CssParseError[];
+  };
+};
+```
+
+#### `CssRuleAST`
+Represents a CSS rule (selector + declarations).
+
+```typescript
+type CssRuleAST = {
+  type: CssTypes.rule;
+  selectors: string[];
+  declarations: CssDeclarationAST[];
+  position?: CssPosition;
+  parent?: CssStylesheetAST;
+};
+```
+
+#### `CssDeclarationAST`
+Represents a CSS property declaration.
+
+```typescript
+type CssDeclarationAST = {
+  type: CssTypes.declaration;
+  property: string;
+  value: string;
+  position?: CssPosition;
+  parent?: CssRuleAST;
+};
+```
+
+#### `CssMediaAST`
+Represents a CSS @media rule.
+
+```typescript
+type CssMediaAST = {
+  type: CssTypes.media;
+  media: string;
+  rules: CssRuleAST[];
+  position?: CssPosition;
+  parent?: CssStylesheetAST;
+};
+```
+
+#### `CssKeyframesAST`
+Represents a CSS @keyframes rule.
+
+```typescript
+type CssKeyframesAST = {
+  type: CssTypes.keyframes;
+  name: string;
+  keyframes: CssKeyframeAST[];
+  position?: CssPosition;
+  parent?: CssStylesheetAST;
+};
+```
+
+#### `CssPosition`
+Represents source position information.
+
+```typescript
+type CssPosition = {
+  source?: string;
+  start: {
+    line: number;
+    column: number;
+  };
+  end: {
+    line: number;
+    column: number;
+  };
+};
+```
+
+#### `CssParseError`
+Represents a parsing error.
+
+```typescript
+type CssParseError = {
+  message: string;
+  reason: string;
+  filename?: string;
+  line: number;
+  column: number;
+  source?: string;
+};
+```
+
+### Compiler Options
+
+#### `CompilerOptions`
+Options for the stringifier.
+
+```typescript
+type CompilerOptions = {
+  indent?: string;    // Default: '  '
+  compress?: boolean; // Default: false
+};
+```
+
+## Error Handling
+
+### Silent Parsing
+
+When parsing malformed CSS, you can use the `silent` option to collect errors instead of throwing:
+
+```javascript
+import { parse } from '@adobe/css-tools';
+
+const malformedCss = `
+  body { color: red; }
+  { color: blue; } /* Missing selector */
+  .valid { background: green; }
+`;
+
+const result = parse(malformedCss, { silent: true });
+
+if (result.stylesheet.parsingErrors) {
+  result.stylesheet.parsingErrors.forEach(error => {
+    console.log(`Error at line ${error.line}: ${error.message}`);
+  });
+}
+
+// Valid rules are still parsed
+console.log('Valid rules:', result.stylesheet.rules.length);
+```
+
+### Source Tracking
+
+Enable source tracking for better error reporting:
+
+```javascript
+import { parse } from '@adobe/css-tools';
+
+const css = 'body { color: red; }';
+const ast = parse(css, { source: 'styles.css' });
+
+const rule = ast.stylesheet.rules[0];
+console.log(rule.position?.source); // "styles.css"
+console.log(rule.position?.start);  // { line: 1, column: 1 }
+console.log(rule.position?.end);    // { line: 1, column: 20 }
+```
+
+## Advanced Usage
+
+### Working with At-Rules
+
+```javascript
+import { parse, stringify } from '@adobe/css-tools';
+
+const css = `
+  @media (max-width: 768px) {
+    .container {
+      padding: 10px;
+    }
+  }
+  
+  @keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+  }
+`;
+
+const ast = parse(css);
+
+// Access media rules
+const mediaRule = ast.stylesheet.rules.find(rule => rule.type === 'media');
+console.log(mediaRule.media); // "(max-width: 768px)"
+
+// Access keyframes
+const keyframesRule = ast.stylesheet.rules.find(rule => rule.type === 'keyframes');
+console.log(keyframesRule.name); // "fadeIn"
+```
+
+### Custom Formatting
+
+```javascript
+import { parse, stringify } from '@adobe/css-tools';
+
+const css = '.example{color:red;font-size:16px}';
+const ast = parse(css);
+
+// Custom indentation
+const formatted = stringify(ast, { indent: '    ' });
+console.log(formatted);
+// Output:
+// .example {
+//     color: red;
+//     font-size: 16px;
+// }
+
+// Compressed with no spaces
+const compressed = stringify(ast, { compress: true });
+console.log(compressed);
+// Output: .example{color:red;font-size:16px}
+```
+
+## TypeScript Integration
+
+The library provides comprehensive TypeScript support with full type definitions for all AST nodes and functions:
+
+```typescript
+import { parse, stringify, type CssStylesheetAST } from '@adobe/css-tools';
+
+const css: string = '.example { color: red; }';
+const ast: CssStylesheetAST = parse(css);
+const output: string = stringify(ast);
+```
+
+## Performance Considerations
+
+- The parser is optimized for large CSS files
+- AST nodes are lightweight and memory-efficient
+- Stringification is fast and supports streaming for large outputs
+- Consider using `compress: true` for production builds to reduce file size
+
+## Browser Support
+
+The library works in all modern browsers and Node.js environments. For older environments, you may need to use a bundler with appropriate polyfills.

control-plane-ui/node_modules/@adobe/css-tools/docs/AST.md

@@ -0,0 +1,366 @@
+# Abstract Syntax Tree (AST)
+
+## Overview
+
+The AST represents CSS as a tree structure where each node has a specific type and properties. All nodes share common properties and have type-specific properties.
+
+## Common Properties
+
+All AST nodes have these properties:
+
+### `type`
+
+The node type as a string. See [Node Types](#node-types) for all possible values.
+
+### `position` (optional)
+
+Position information for the node in the source code:
+
+```typescript
+{
+  start: { line: number; column: number };
+  end: { line: number; column: number };
+  source?: string;
+}
+```
+
+### `parent` (optional)
+
+Reference to the parent node in the AST.
+
+## Node Types
+
+### `stylesheet`
+
+The root node representing an entire CSS document.
+
+**Properties:**
+- `stylesheet.source` (optional): Source file path
+- `stylesheet.rules`: Array of top-level rules
+- `stylesheet.parsingErrors` (optional): Array of parse errors when `silent` option is used
+
+**Example:**
+```json
+{
+  "type": "stylesheet",
+  "stylesheet": {
+    "rules": [
+      // ... other nodes
+    ]
+  }
+}
+```
+
+### `rule`
+
+A CSS rule with selectors and declarations.
+
+**Properties:**
+- `selectors`: Array of CSS selectors as strings
+- `declarations`: Array of declarations and comments
+
+**Example:**
+```json
+{
+  "type": "rule",
+  "selectors": ["body", "html"],
+  "declarations": [
+    {
+      "type": "declaration",
+      "property": "color",
+      "value": "red"
+    }
+  ]
+}
+```
+
+### `declaration`
+
+A CSS property declaration.
+
+**Properties:**
+- `property`: The CSS property name
+- `value`: The CSS property value as a string
+
+**Example:**
+```json
+{
+  "type": "declaration",
+  "property": "background-color",
+  "value": "#ffffff"
+}
+```
+
+### `comment`
+
+A CSS comment.
+
+**Properties:**
+- `comment`: The comment text (without `/*` and `*/`)
+
+**Example:**
+```json
+{
+  "type": "comment",
+  "comment": " This is a comment "
+}
+```
+
+### `media`
+
+A `@media` rule.
+
+**Properties:**
+- `media`: The media query string
+- `rules`: Array of rules within the media block
+
+**Example:**
+```json
+{
+  "type": "media",
+  "media": "screen and (max-width: 768px)",
+  "rules": [
+    // ... nested rules
+  ]
+}
+```
+
+### `keyframes`
+
+A `@keyframes` rule.
+
+**Properties:**
+- `name`: The keyframes name
+- `vendor` (optional): Vendor prefix (e.g., "-webkit-")
+- `keyframes`: Array of keyframe rules and comments
+
+**Example:**
+```json
+{
+  "type": "keyframes",
+  "name": "fade",
+  "keyframes": [
+    {
+      "type": "keyframe",
+      "values": ["from"],
+      "declarations": [
+        {
+          "type": "declaration",
+          "property": "opacity",
+          "value": "0"
+        }
+      ]
+    }
+  ]
+}
+```
+
+### `keyframe`
+
+A keyframe within a `@keyframes` rule.
+
+**Properties:**
+- `values`: Array of keyframe selectors (e.g., `["from"]`, `["to"]`, `["50%"]`)
+- `declarations`: Array of declarations and comments
+
+### `import`
+
+An `@import` rule.
+
+**Properties:**
+- `import`: The import string (URL or media query)
+
+**Example:**
+```json
+{
+  "type": "import",
+  "import": "url('styles.css')"
+}
+```
+
+### `charset`
+
+A `@charset` rule.
+
+**Properties:**
+- `charset`: The character encoding
+
+**Example:**
+```json
+{
+  "type": "charset",
+  "charset": "utf-8"
+}
+```
+
+### `namespace`
+
+A `@namespace` rule.
+
+**Properties:**
+- `namespace`: The namespace declaration
+
+**Example:**
+```json
+{
+  "type": "namespace",
+  "namespace": "url(http://www.w3.org/1999/xhtml)"
+}
+```
+
+### `supports`
+
+A `@supports` rule.
+
+**Properties:**
+- `supports`: The supports condition
+- `rules`: Array of rules within the supports block
+
+**Example:**
+```json
+{
+  "type": "supports",
+  "supports": "(display: grid)",
+  "rules": [
+    // ... nested rules
+  ]
+}
+```
+
+### `document`
+
+A `@document` rule.
+
+**Properties:**
+- `document`: The document condition
+- `vendor` (optional): Vendor prefix
+- `rules`: Array of rules within the document block
+
+### `page`
+
+A `@page` rule.
+
+**Properties:**
+- `selectors`: Array of page selectors
+- `declarations`: Array of declarations and comments
+
+### `font-face`
+
+A `@font-face` rule.
+
+**Properties:**
+- `declarations`: Array of font declarations and comments
+
+### `host`
+
+A `:host` rule.
+
+**Properties:**
+- `rules`: Array of rules within the host block
+
+### `container`
+
+A `@container` rule.
+
+**Properties:**
+- `container`: The container query
+- `rules`: Array of rules within the container block
+
+### `layer`
+
+A `@layer` rule.
+
+**Properties:**
+- `layer`: The layer name
+- `rules` (optional): Array of rules within the layer block
+
+### `custom-media`
+
+A `@custom-media` rule.
+
+**Properties:**
+- `name`: The custom media query name
+- `media`: The media query definition
+
+### `starting-style`
+
+A `@starting-style` rule.
+
+**Properties:**
+- `rules`: Array of rules within the starting-style block
+
+## Type Hierarchy
+
+The AST nodes are organized in the following hierarchy:
+
+- `CssStylesheetAST` - Root node
+- `CssAtRuleAST` - Union of all at-rule and rule nodes
+- `CssAllNodesAST` - Union of all possible node types
+
+## Working with the AST
+
+### Traversing Nodes
+
+```typescript
+import { parse, CssStylesheetAST } from '@adobe/css-tools';
+
+const ast: CssStylesheetAST = parse('body { color: red; }');
+
+// Access top-level rules
+ast.stylesheet.rules.forEach(rule => {
+  if (rule.type === 'rule') {
+    console.log('Selectors:', rule.selectors);
+    rule.declarations.forEach(decl => {
+      if (decl.type === 'declaration') {
+        console.log(`${decl.property}: ${decl.value}`);
+      }
+    });
+  }
+});
+```
+
+### Modifying Nodes
+
+```typescript
+// Add a new declaration
+const newDecl = {
+  type: 'declaration' as const,
+  property: 'font-size',
+  value: '16px'
+};
+
+// Find a rule and add the declaration
+ast.stylesheet.rules.forEach(rule => {
+  if (rule.type === 'rule' && rule.selectors.includes('body')) {
+    rule.declarations.push(newDecl);
+  }
+});
+```
+
+### Error Handling
+
+When parsing with the `silent` option, errors are collected in the AST:
+
+```typescript
+const ast = parse('invalid css {', { silent: true });
+
+if (ast.stylesheet.parsingErrors) {
+  ast.stylesheet.parsingErrors.forEach(error => {
+    console.error('Parse error:', error.message);
+  });
+}
+```
+
+## Position Information
+
+Position information is available on most nodes and includes:
+
+- `start.line` and `start.column`: Beginning of the node
+- `end.line` and `end.column`: End of the node  
+- `source`: Source file path (if provided during parsing)
+
+This is useful for:
+- Error reporting
+- Source mapping
+- Code analysis tools
+- IDE integration

control-plane-ui/node_modules/@adobe/css-tools/docs/CHANGELOG.md

@@ -0,0 +1,191 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [4.4.4] - 2025-07-22
+
+### Changed
+- Switch from yarn to npm for package management
+- Switch from eslint to biome for code formatting and linting
+- Reformat codebase to comply with biome recommendations
+- Switch from webpack to rollup for bundling
+
+### Fixed
+- Fix module exports to ensure proper compatibility with bundlers
+- Add validation check to prevent future export issues
+
+## [4.4.3] - 2025-05-15
+
+### Security
+- Fix polynomial regular expression vulnerability on uncontrolled data
+- Refactor code to enable GitHub security static analysis
+
+### Performance
+- Improve parsing performance with minor optimizations
+- Replace regex patterns with string search (indexOf-based) for better performance
+
+### Added
+- Add new utility functions with comprehensive unit tests
+- Add improved formatting for CSS Grid template areas (#283 by @jogibear9988)
+
+### Fixed
+- Fix TypeScript error with ConstructorParameters in Parcel bundler (#444)
+
+## [4.4.2] - 2025-02-12
+
+### Fixed
+- Fix regular expression for parsing quoted values in parentheses
+
+## [4.4.0] - 2024-06-05
+
+### Added
+- Add support for CSS `@starting-style` at-rule (#319)
+
+## [4.3.3] - 2024-01-24
+
+### Changed
+- Update package export configuration (#271)
+
+## [4.3.2] - 2023-11-28
+
+### Security
+- Fix ReDoS vulnerability with crafted CSS strings - CVE-2023-48631
+
+### Fixed
+- Fix parsing issues with `:is()` and nested `:nth-child()` selectors (#211)
+
+## [4.3.1] - 2023-03-14
+
+### Security
+- Fix ReDoS vulnerability with crafted CSS strings - CVE-2023-26364
+
+## [4.3.0] - 2023-03-07
+
+### Changed
+- Update build toolchain and dependencies
+- Update package exports configuration and file structure
+
+## [4.2.0] - 2023-02-21
+
+### Added
+- Add support for CSS `@container` at-rule
+- Add support for CSS `@layer` at-rule
+
+## [4.1.0] - 2023-01-25
+
+### Added
+- Add support for ES Modules (ESM)
+
+## [4.0.2] - 2023-01-12
+
+### Fixed
+- Fix `@import` parsing when URL contains semicolons (#71)
+- Fix regression in selector parsing for attribute selectors (#77)
+
+## [4.0.1] - 2022-08-03
+
+### Fixed
+- Fix `globalThis` configuration for webpack to enable UMD module usage in Node.js environments
+
+## [4.0.0] - 2022-06-09
+
+### Changed
+- Fork from original css library to Adobe's `@adobe/css-tools` package
+- Convert codebase from JavaScript to TypeScript
+- Improve parsing performance by approximately 25%
+- Update all dependencies to latest versions
+- Remove source map support
+
+---
+
+## Legacy Versions (Pre-Adobe Fork)
+
+## [3.0.0] - 2020-07-01
+
+### Changed
+- Bump major version due to major dependency updates and Node.js version requirement changes
+
+## [2.2.1] - 2015-06-17
+
+### Fixed
+- Fix parsing of escaped quotes in quoted strings
+
+## [2.2.0] - 2015-02-18
+
+### Added
+- Add `parsingErrors` property to list errors when parsing with `silent: true`
+- Accept EOL characters and all whitespace characters in at-rules such as `@media`
+
+## [2.1.0] - 2014-08-05
+
+### Added
+- Add `inputSourcemaps` option to disable input source map processing
+- Add `sourcemap: 'generator'` option to return the `SourceMapGenerator` object
+- Use `inherits` package for inheritance (fixes browser compatibility issues)
+
+### Changed
+- Change error message format and add `.reason` property to error objects
+
+## [2.0.0] - 2014-06-18
+
+### Added
+- Add non-enumerable parent reference to each AST node
+- Add support for `@custom-media`, `@host`, and `@font-face` at-rules
+- Allow commas inside selector functions
+- Allow empty property values
+- Add `node.position.content` property
+- Integrate css-parse and css-stringify libraries
+- Apply original source maps from source files
+
+### Changed
+- Change default `options.position` value to `true`
+- Remove comments from properties and values
+
+### Removed
+- Drop Component(1) support
+
+### Fixed
+- Fix assertion errors when selectors are missing
+
+## [1.6.1] - 2014-01-02
+
+### Fixed
+- Fix component.json configuration
+
+## [1.6.0] - 2013-12-21
+
+### Changed
+- Update dependencies
+
+## [1.5.0] - 2013-12-03
+
+### Changed
+- Update dependencies
+
+## [1.1.0] - 2013-04-04
+
+### Changed
+- Update dependencies
+
+## [1.0.7] - 2012-11-21
+
+### Fixed
+- Fix component.json configuration
+
+## [1.0.4] - 2012-11-15
+
+### Changed
+- Update css-stringify dependency
+
+## [1.0.3] - 2012-09-01
+
+### Added
+- Add Component support
+
+## [0.0.1] - 2010-01-03
+
+### Added
+- Initial release