@ceed/cds 0.0.185 → 0.0.187-cjs.0

package/dist/external/@mui/system/createStyled.js

@@ -0,0 +1,272 @@
+'use strict';
+
+var createStyled = require('../../../_virtual/createStyled2.js');
+var interopRequireDefault = require('../../@babel/runtime/helpers/interopRequireDefault.js');
+var _extends = require('../../@babel/runtime/helpers/extends.js');
+var objectWithoutPropertiesLoose = require('../../@babel/runtime/helpers/objectWithoutPropertiesLoose.js');
+var index$4 = require('../../../_virtual/index5.js');
+var index$5 = require('../../../_virtual/index6.js');
+var index = require('../../../_virtual/index7.js');
+var index$1 = require('../../../_virtual/index8.js');
+var index$2 = require('../../../_virtual/index9.js');
+var index$3 = require('../../../_virtual/index10.js');
+
+var hasRequiredCreateStyled;
+
+function requireCreateStyled () {
+	if (hasRequiredCreateStyled) return createStyled.__exports;
+	hasRequiredCreateStyled = 1;
+
+	var _interopRequireDefault = interopRequireDefault.__require();
+	Object.defineProperty(createStyled.__exports, "__esModule", {
+	  value: true
+	});
+	createStyled.__exports.default = createStyled$1;
+	createStyled.__exports.shouldForwardProp = shouldForwardProp;
+	createStyled.__exports.systemDefaultTheme = undefined;
+	var _extends2 = _interopRequireDefault(_extends.__require());
+	var _objectWithoutPropertiesLoose2 = _interopRequireDefault(objectWithoutPropertiesLoose.__require());
+	var _styledEngine = _interopRequireWildcard(index$4);
+	var _deepmerge = index$5;
+	var _capitalize = _interopRequireDefault(index);
+	var _getDisplayName = _interopRequireDefault(index$1);
+	var _createTheme = _interopRequireDefault(index$2);
+	var _styleFunctionSx = _interopRequireDefault(index$3);
+	const _excluded = ["ownerState"],
+	  _excluded2 = ["variants"],
+	  _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"];
+	/* eslint-disable no-underscore-dangle */
+	function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+	function _interopRequireWildcard(e, r) { if (e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+	function isEmpty(obj) {
+	  return Object.keys(obj).length === 0;
+	}
+
+	// https://github.com/emotion-js/emotion/blob/26ded6109fcd8ca9875cc2ce4564fee678a3f3c5/packages/styled/src/utils.js#L40
+	function isStringTag(tag) {
+	  return typeof tag === 'string' &&
+	  // 96 is one less than the char code
+	  // for "a" so this is checking that
+	  // it's a lowercase character
+	  tag.charCodeAt(0) > 96;
+	}
+
+	// Update /system/styled/#api in case if this changes
+	function shouldForwardProp(prop) {
+	  return prop !== 'ownerState' && prop !== 'theme' && prop !== 'sx' && prop !== 'as';
+	}
+	const systemDefaultTheme = createStyled.__exports.systemDefaultTheme = (0, _createTheme.default)();
+	const lowercaseFirstLetter = string => {
+	  if (!string) {
+	    return string;
+	  }
+	  return string.charAt(0).toLowerCase() + string.slice(1);
+	};
+	function resolveTheme({
+	  defaultTheme,
+	  theme,
+	  themeId
+	}) {
+	  return isEmpty(theme) ? defaultTheme : theme[themeId] || theme;
+	}
+	function defaultOverridesResolver(slot) {
+	  if (!slot) {
+	    return null;
+	  }
+	  return (props, styles) => styles[slot];
+	}
+	function processStyleArg(callableStyle, _ref) {
+	  let {
+	      ownerState
+	    } = _ref,
+	    props = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+	  const resolvedStylesArg = typeof callableStyle === 'function' ? callableStyle((0, _extends2.default)({
+	    ownerState
+	  }, props)) : callableStyle;
+	  if (Array.isArray(resolvedStylesArg)) {
+	    return resolvedStylesArg.flatMap(resolvedStyle => processStyleArg(resolvedStyle, (0, _extends2.default)({
+	      ownerState
+	    }, props)));
+	  }
+	  if (!!resolvedStylesArg && typeof resolvedStylesArg === 'object' && Array.isArray(resolvedStylesArg.variants)) {
+	    const {
+	        variants = []
+	      } = resolvedStylesArg,
+	      otherStyles = (0, _objectWithoutPropertiesLoose2.default)(resolvedStylesArg, _excluded2);
+	    let result = otherStyles;
+	    variants.forEach(variant => {
+	      let isMatch = true;
+	      if (typeof variant.props === 'function') {
+	        isMatch = variant.props((0, _extends2.default)({
+	          ownerState
+	        }, props, ownerState));
+	      } else {
+	        Object.keys(variant.props).forEach(key => {
+	          if ((ownerState == null ? undefined : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) {
+	            isMatch = false;
+	          }
+	        });
+	      }
+	      if (isMatch) {
+	        if (!Array.isArray(result)) {
+	          result = [result];
+	        }
+	        result.push(typeof variant.style === 'function' ? variant.style((0, _extends2.default)({
+	          ownerState
+	        }, props, ownerState)) : variant.style);
+	      }
+	    });
+	    return result;
+	  }
+	  return resolvedStylesArg;
+	}
+	function createStyled$1(input = {}) {
+	  const {
+	    themeId,
+	    defaultTheme = systemDefaultTheme,
+	    rootShouldForwardProp = shouldForwardProp,
+	    slotShouldForwardProp = shouldForwardProp
+	  } = input;
+	  const systemSx = props => {
+	    return (0, _styleFunctionSx.default)((0, _extends2.default)({}, props, {
+	      theme: resolveTheme((0, _extends2.default)({}, props, {
+	        defaultTheme,
+	        themeId
+	      }))
+	    }));
+	  };
+	  systemSx.__mui_systemSx = true;
+	  return (tag, inputOptions = {}) => {
+	    // Filter out the `sx` style function from the previous styled component to prevent unnecessary styles generated by the composite components.
+	    (0, _styledEngine.internal_processStyles)(tag, styles => styles.filter(style => !(style != null && style.__mui_systemSx)));
+	    const {
+	        name: componentName,
+	        slot: componentSlot,
+	        skipVariantsResolver: inputSkipVariantsResolver,
+	        skipSx: inputSkipSx,
+	        // TODO v6: remove `lowercaseFirstLetter()` in the next major release
+	        // For more details: https://github.com/mui/material-ui/pull/37908
+	        overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(componentSlot))
+	      } = inputOptions,
+	      options = (0, _objectWithoutPropertiesLoose2.default)(inputOptions, _excluded3);
+
+	    // if skipVariantsResolver option is defined, take the value, otherwise, true for root and false for other slots.
+	    const skipVariantsResolver = inputSkipVariantsResolver !== undefined ? inputSkipVariantsResolver :
+	    // TODO v6: remove `Root` in the next major release
+	    // For more details: https://github.com/mui/material-ui/pull/37908
+	    componentSlot && componentSlot !== 'Root' && componentSlot !== 'root' || false;
+	    const skipSx = inputSkipSx || false;
+	    let label;
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (componentName) {
+	        // TODO v6: remove `lowercaseFirstLetter()` in the next major release
+	        // For more details: https://github.com/mui/material-ui/pull/37908
+	        label = `${componentName}-${lowercaseFirstLetter(componentSlot || 'Root')}`;
+	      }
+	    }
+	    let shouldForwardPropOption = shouldForwardProp;
+
+	    // TODO v6: remove `Root` in the next major release
+	    // For more details: https://github.com/mui/material-ui/pull/37908
+	    if (componentSlot === 'Root' || componentSlot === 'root') {
+	      shouldForwardPropOption = rootShouldForwardProp;
+	    } else if (componentSlot) {
+	      // any other slot specified
+	      shouldForwardPropOption = slotShouldForwardProp;
+	    } else if (isStringTag(tag)) {
+	      // for string (html) tag, preserve the behavior in emotion & styled-components.
+	      shouldForwardPropOption = undefined;
+	    }
+	    const defaultStyledResolver = (0, _styledEngine.default)(tag, (0, _extends2.default)({
+	      shouldForwardProp: shouldForwardPropOption,
+	      label
+	    }, options));
+	    const transformStyleArg = stylesArg => {
+	      // On the server Emotion doesn't use React.forwardRef for creating components, so the created
+	      // component stays as a function. This condition makes sure that we do not interpolate functions
+	      // which are basically components used as a selectors.
+	      if (typeof stylesArg === 'function' && stylesArg.__emotion_real !== stylesArg || (0, _deepmerge.isPlainObject)(stylesArg)) {
+	        return props => processStyleArg(stylesArg, (0, _extends2.default)({}, props, {
+	          theme: resolveTheme({
+	            theme: props.theme,
+	            defaultTheme,
+	            themeId
+	          })
+	        }));
+	      }
+	      return stylesArg;
+	    };
+	    const muiStyledResolver = (styleArg, ...expressions) => {
+	      let transformedStyleArg = transformStyleArg(styleArg);
+	      const expressionsWithDefaultTheme = expressions ? expressions.map(transformStyleArg) : [];
+	      if (componentName && overridesResolver) {
+	        expressionsWithDefaultTheme.push(props => {
+	          const theme = resolveTheme((0, _extends2.default)({}, props, {
+	            defaultTheme,
+	            themeId
+	          }));
+	          if (!theme.components || !theme.components[componentName] || !theme.components[componentName].styleOverrides) {
+	            return null;
+	          }
+	          const styleOverrides = theme.components[componentName].styleOverrides;
+	          const resolvedStyleOverrides = {};
+	          // TODO: v7 remove iteration and use `resolveStyleArg(styleOverrides[slot])` directly
+	          Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => {
+	            resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, (0, _extends2.default)({}, props, {
+	              theme
+	            }));
+	          });
+	          return overridesResolver(props, resolvedStyleOverrides);
+	        });
+	      }
+	      if (componentName && !skipVariantsResolver) {
+	        expressionsWithDefaultTheme.push(props => {
+	          var _theme$components;
+	          const theme = resolveTheme((0, _extends2.default)({}, props, {
+	            defaultTheme,
+	            themeId
+	          }));
+	          const themeVariants = theme == null || (_theme$components = theme.components) == null || (_theme$components = _theme$components[componentName]) == null ? undefined : _theme$components.variants;
+	          return processStyleArg({
+	            variants: themeVariants
+	          }, (0, _extends2.default)({}, props, {
+	            theme
+	          }));
+	        });
+	      }
+	      if (!skipSx) {
+	        expressionsWithDefaultTheme.push(systemSx);
+	      }
+	      const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length;
+	      if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) {
+	        const placeholders = new Array(numOfCustomFnsApplied).fill('');
+	        // If the type is array, than we need to add placeholders in the template for the overrides, variants and the sx styles.
+	        transformedStyleArg = [...styleArg, ...placeholders];
+	        transformedStyleArg.raw = [...styleArg.raw, ...placeholders];
+	      }
+	      const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme);
+	      if (process.env.NODE_ENV !== 'production') {
+	        let displayName;
+	        if (componentName) {
+	          displayName = `${componentName}${(0, _capitalize.default)(componentSlot || '')}`;
+	        }
+	        if (displayName === undefined) {
+	          displayName = `Styled(${(0, _getDisplayName.default)(tag)})`;
+	        }
+	        Component.displayName = displayName;
+	      }
+	      if (tag.muiName) {
+	        Component.muiName = tag.muiName;
+	      }
+	      return Component;
+	    };
+	    if (defaultStyledResolver.withConfig) {
+	      muiStyledResolver.withConfig = defaultStyledResolver.withConfig;
+	    }
+	    return muiStyledResolver;
+	  };
+	}
+	return createStyled.__exports;
+}
+
+exports.__require = requireCreateStyled;

package/dist/external/@mui/system/esm/borders.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var responsivePropType = require('./responsivePropType.js');
+var style = require('./style.js');
+var compose = require('./compose.js');
+var spacing = require('./spacing.js');
+var breakpoints = require('./breakpoints.js');
+
+function borderTransform(value) {
+  if (typeof value !== 'number') {
+    return value;
+  }
+  return `${value}px solid`;
+}
+function createBorderStyle(prop, transform) {
+  return style.default({
+    prop,
+    themeKey: 'borders',
+    transform
+  });
+}
+const border = createBorderStyle('border', borderTransform);
+const borderTop = createBorderStyle('borderTop', borderTransform);
+const borderRight = createBorderStyle('borderRight', borderTransform);
+const borderBottom = createBorderStyle('borderBottom', borderTransform);
+const borderLeft = createBorderStyle('borderLeft', borderTransform);
+const borderColor = createBorderStyle('borderColor');
+const borderTopColor = createBorderStyle('borderTopColor');
+const borderRightColor = createBorderStyle('borderRightColor');
+const borderBottomColor = createBorderStyle('borderBottomColor');
+const borderLeftColor = createBorderStyle('borderLeftColor');
+const outline = createBorderStyle('outline', borderTransform);
+const outlineColor = createBorderStyle('outlineColor');
+
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const borderRadius = props => {
+  if (props.borderRadius !== undefined && props.borderRadius !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'shape.borderRadius', 4, 'borderRadius');
+    const styleFromPropValue = propValue => ({
+      borderRadius: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.borderRadius, styleFromPropValue);
+  }
+  return null;
+};
+borderRadius.propTypes = process.env.NODE_ENV !== 'production' ? {
+  borderRadius: responsivePropType
+} : {};
+borderRadius.filterProps = ['borderRadius'];
+compose(border, borderTop, borderRight, borderBottom, borderLeft, borderColor, borderTopColor, borderRightColor, borderBottomColor, borderLeftColor, borderRadius, outline, outlineColor);
+
+exports.border = border;
+exports.borderBottom = borderBottom;
+exports.borderBottomColor = borderBottomColor;
+exports.borderColor = borderColor;
+exports.borderLeft = borderLeft;
+exports.borderLeftColor = borderLeftColor;
+exports.borderRadius = borderRadius;
+exports.borderRight = borderRight;
+exports.borderRightColor = borderRightColor;
+exports.borderTop = borderTop;
+exports.borderTopColor = borderTopColor;
+exports.borderTransform = borderTransform;
+exports.outline = outline;
+exports.outlineColor = outlineColor;

package/dist/external/@mui/system/esm/breakpoints.js

@@ -0,0 +1,71 @@
+'use strict';
+
+// The breakpoint **start** at this value.
+// For instance with the first breakpoint xs: [xs, sm[.
+const values = {
+  xs: 0,
+  // phone
+  sm: 600,
+  // tablet
+  md: 900,
+  // small laptop
+  lg: 1200,
+  // desktop
+  xl: 1536 // large screen
+};
+const defaultBreakpoints = {
+  // Sorted ASC by size. That's important.
+  // It can't be configured as it's used statically for propTypes.
+  keys: ['xs', 'sm', 'md', 'lg', 'xl'],
+  up: key => `@media (min-width:${values[key]}px)`
+};
+function handleBreakpoints(props, propValue, styleFromPropValue) {
+  const theme = props.theme || {};
+  if (Array.isArray(propValue)) {
+    const themeBreakpoints = theme.breakpoints || defaultBreakpoints;
+    return propValue.reduce((acc, item, index) => {
+      acc[themeBreakpoints.up(themeBreakpoints.keys[index])] = styleFromPropValue(propValue[index]);
+      return acc;
+    }, {});
+  }
+  if (typeof propValue === 'object') {
+    const themeBreakpoints = theme.breakpoints || defaultBreakpoints;
+    return Object.keys(propValue).reduce((acc, breakpoint) => {
+      // key is breakpoint
+      if (Object.keys(themeBreakpoints.values || values).indexOf(breakpoint) !== -1) {
+        const mediaKey = themeBreakpoints.up(breakpoint);
+        acc[mediaKey] = styleFromPropValue(propValue[breakpoint], breakpoint);
+      } else {
+        const cssKey = breakpoint;
+        acc[cssKey] = propValue[cssKey];
+      }
+      return acc;
+    }, {});
+  }
+  const output = styleFromPropValue(propValue);
+  return output;
+}
+function createEmptyBreakpointObject(breakpointsInput = {}) {
+  var _breakpointsInput$key;
+  const breakpointsInOrder = (_breakpointsInput$key = breakpointsInput.keys) == null ? undefined : _breakpointsInput$key.reduce((acc, key) => {
+    const breakpointStyleKey = breakpointsInput.up(key);
+    acc[breakpointStyleKey] = {};
+    return acc;
+  }, {});
+  return breakpointsInOrder || {};
+}
+function removeUnusedBreakpoints(breakpointKeys, style) {
+  return breakpointKeys.reduce((acc, key) => {
+    const breakpointOutput = acc[key];
+    const isBreakpointUnused = !breakpointOutput || Object.keys(breakpointOutput).length === 0;
+    if (isBreakpointUnused) {
+      delete acc[key];
+    }
+    return acc;
+  }, style);
+}
+
+exports.createEmptyBreakpointObject = createEmptyBreakpointObject;
+exports.handleBreakpoints = handleBreakpoints;
+exports.removeUnusedBreakpoints = removeUnusedBreakpoints;
+exports.values = values;

package/dist/external/@mui/system/esm/compose.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var merge = require('./merge.js');
+
+function compose(...styles) {
+  const handlers = styles.reduce((acc, style) => {
+    style.filterProps.forEach(prop => {
+      acc[prop] = style;
+    });
+    return acc;
+  }, {});
+
+  // false positive
+  // eslint-disable-next-line react/function-component-definition
+  const fn = props => {
+    return Object.keys(props).reduce((acc, prop) => {
+      if (handlers[prop]) {
+        return merge(acc, handlers[prop](props));
+      }
+      return acc;
+    }, {});
+  };
+  fn.propTypes = process.env.NODE_ENV !== 'production' ? styles.reduce((acc, style) => Object.assign(acc, style.propTypes), {}) : {};
+  fn.filterProps = styles.reduce((acc, style) => acc.concat(style.filterProps), []);
+  return fn;
+}
+
+module.exports = compose;

package/dist/external/@mui/system/esm/createTheme/applyStyles.js

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * A universal utility to style components with multiple color modes. Always use it from the theme object.
+ * It works with:
+ *  - [Basic theme](https://mui.com/material-ui/customization/dark-mode/)
+ *  - [CSS theme variables](https://mui.com/material-ui/experimental-api/css-theme-variables/overview/)
+ *  - Zero-runtime engine
+ *
+ * Tips: Use an array over object spread and place `theme.applyStyles()` last.
+ *
+ * ✅ [{ background: '#e5e5e5' }, theme.applyStyles('dark', { background: '#1c1c1c' })]
+ *
+ * 🚫 { background: '#e5e5e5', ...theme.applyStyles('dark', { background: '#1c1c1c' })}
+ *
+ * @example
+ * 1. using with `styled`:
+ * ```jsx
+ *   const Component = styled('div')(({ theme }) => [
+ *     { background: '#e5e5e5' },
+ *     theme.applyStyles('dark', {
+ *       background: '#1c1c1c',
+ *       color: '#fff',
+ *     }),
+ *   ]);
+ * ```
+ *
+ * @example
+ * 2. using with `sx` prop:
+ * ```jsx
+ *   <Box sx={theme => [
+ *     { background: '#e5e5e5' },
+ *     theme.applyStyles('dark', {
+ *        background: '#1c1c1c',
+ *        color: '#fff',
+ *      }),
+ *     ]}
+ *   />
+ * ```
+ *
+ * @example
+ * 3. theming a component:
+ * ```jsx
+ *   extendTheme({
+ *     components: {
+ *       MuiButton: {
+ *         styleOverrides: {
+ *           root: ({ theme }) => [
+ *             { background: '#e5e5e5' },
+ *             theme.applyStyles('dark', {
+ *               background: '#1c1c1c',
+ *               color: '#fff',
+ *             }),
+ *           ],
+ *         },
+ *       }
+ *     }
+ *   })
+ *```
+ */
+function applyStyles(key, styles) {
+  // @ts-expect-error this is 'any' type
+  const theme = this;
+  if (theme.vars && typeof theme.getColorSchemeSelector === 'function') {
+    // If CssVarsProvider is used as a provider,
+    // returns '* :where([data-mui-color-scheme="light|dark"]) &'
+    const selector = theme.getColorSchemeSelector(key).replace(/(\[[^\]]+\])/, '*:where($1)');
+    return {
+      [selector]: styles
+    };
+  }
+  if (theme.palette.mode === key) {
+    return styles;
+  }
+  return {};
+}
+
+module.exports = applyStyles;

package/dist/external/@mui/system/esm/createTheme/createBreakpoints.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var objectWithoutPropertiesLoose = require('../../../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js');
+var _extends = require('../../../../@babel/runtime/helpers/esm/extends.js');
+
+const _excluded = ["values", "unit", "step"];
+const sortBreakpointsValues = values => {
+  const breakpointsAsArray = Object.keys(values).map(key => ({
+    key,
+    val: values[key]
+  })) || [];
+  // Sort in ascending order
+  breakpointsAsArray.sort((breakpoint1, breakpoint2) => breakpoint1.val - breakpoint2.val);
+  return breakpointsAsArray.reduce((acc, obj) => {
+    return _extends({}, acc, {
+      [obj.key]: obj.val
+    });
+  }, {});
+};
+
+// Keep in mind that @media is inclusive by the CSS specification.
+function createBreakpoints(breakpoints) {
+  const {
+      // The breakpoint **start** at this value.
+      // For instance with the first breakpoint xs: [xs, sm).
+      values = {
+        xs: 0,
+        // phone
+        sm: 600,
+        // tablet
+        md: 900,
+        // small laptop
+        lg: 1200,
+        // desktop
+        xl: 1536 // large screen
+      },
+      unit = 'px',
+      step = 5
+    } = breakpoints,
+    other = objectWithoutPropertiesLoose(breakpoints, _excluded);
+  const sortedValues = sortBreakpointsValues(values);
+  const keys = Object.keys(sortedValues);
+  function up(key) {
+    const value = typeof values[key] === 'number' ? values[key] : key;
+    return `@media (min-width:${value}${unit})`;
+  }
+  function down(key) {
+    const value = typeof values[key] === 'number' ? values[key] : key;
+    return `@media (max-width:${value - step / 100}${unit})`;
+  }
+  function between(start, end) {
+    const endIndex = keys.indexOf(end);
+    return `@media (min-width:${typeof values[start] === 'number' ? values[start] : start}${unit}) and ` + `(max-width:${(endIndex !== -1 && typeof values[keys[endIndex]] === 'number' ? values[keys[endIndex]] : end) - step / 100}${unit})`;
+  }
+  function only(key) {
+    if (keys.indexOf(key) + 1 < keys.length) {
+      return between(key, keys[keys.indexOf(key) + 1]);
+    }
+    return up(key);
+  }
+  function not(key) {
+    // handle first and last key separately, for better readability
+    const keyIndex = keys.indexOf(key);
+    if (keyIndex === 0) {
+      return up(keys[1]);
+    }
+    if (keyIndex === keys.length - 1) {
+      return down(keys[keyIndex]);
+    }
+    return between(key, keys[keys.indexOf(key) + 1]).replace('@media', '@media not all and');
+  }
+  return _extends({
+    keys,
+    values: sortedValues,
+    up,
+    down,
+    between,
+    only,
+    not,
+    unit
+  }, other);
+}
+
+module.exports = createBreakpoints;

package/dist/external/@mui/system/esm/createTheme/createSpacing.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var spacing = require('../spacing.js');
+
+// The different signatures imply different meaning for their arguments that can't be expressed structurally.
+// We express the difference with variable names.
+
+function createSpacing(spacingInput = 8) {
+  // Already transformed.
+  if (spacingInput.mui) {
+    return spacingInput;
+  }
+
+  // Material Design layouts are visually balanced. Most measurements align to an 8dp grid, which aligns both spacing and the overall layout.
+  // Smaller components, such as icons, can align to a 4dp grid.
+  // https://m2.material.io/design/layout/understanding-layout.html
+  const transform = spacing.createUnarySpacing({
+    spacing: spacingInput
+  });
+  const spacing$1 = (...argsInput) => {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!(argsInput.length <= 4)) {
+        console.error(`MUI: Too many arguments provided, expected between 0 and 4, got ${argsInput.length}`);
+      }
+    }
+    const args = argsInput.length === 0 ? [1] : argsInput;
+    return args.map(argument => {
+      const output = transform(argument);
+      return typeof output === 'number' ? `${output}px` : output;
+    }).join(' ');
+  };
+  spacing$1.mui = true;
+  return spacing$1;
+}
+
+module.exports = createSpacing;

package/dist/external/@mui/system/esm/createTheme/createTheme.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var _extends = require('../../../../@babel/runtime/helpers/esm/extends.js');
+var objectWithoutPropertiesLoose = require('../../../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js');
+var createBreakpoints = require('./createBreakpoints.js');
+var shape = require('./shape.js');
+var createSpacing = require('./createSpacing.js');
+var styleFunctionSx = require('../styleFunctionSx/styleFunctionSx.js');
+var defaultSxConfig = require('../styleFunctionSx/defaultSxConfig.js');
+var applyStyles = require('./applyStyles.js');
+var deepmerge = require('../../../utils/deepmerge/deepmerge.js');
+
+const _excluded = ["breakpoints", "palette", "spacing", "shape"];
+function createTheme(options = {}, ...args) {
+  const {
+      breakpoints: breakpointsInput = {},
+      palette: paletteInput = {},
+      spacing: spacingInput,
+      shape: shapeInput = {}
+    } = options,
+    other = objectWithoutPropertiesLoose(options, _excluded);
+  const breakpoints = createBreakpoints(breakpointsInput);
+  const spacing = createSpacing(spacingInput);
+  let muiTheme = deepmerge.default({
+    breakpoints,
+    direction: 'ltr',
+    components: {},
+    // Inject component definitions.
+    palette: _extends({
+      mode: 'light'
+    }, paletteInput),
+    spacing,
+    shape: _extends({}, shape, shapeInput)
+  }, other);
+  muiTheme.applyStyles = applyStyles;
+  muiTheme = args.reduce((acc, argument) => deepmerge.default(acc, argument), muiTheme);
+  muiTheme.unstable_sxConfig = _extends({}, defaultSxConfig, other == null ? undefined : other.unstable_sxConfig);
+  muiTheme.unstable_sx = function sx(props) {
+    return styleFunctionSx.default({
+      sx: props,
+      theme: this
+    });
+  };
+  return muiTheme;
+}
+
+module.exports = createTheme;