Vlad Durnea
cffdf8af86
Some checks failed
CI/CD Pipeline / unit-tests (push) Failing after 1m16s
CI/CD Pipeline / integration-tests (push) Failing after 2m32s
CI/CD Pipeline / lint (push) Successful in 5m22s
CI/CD Pipeline / e2e-tests (push) Has been skipped
CI/CD Pipeline / build (push) Has been skipped
1908 lines
68 KiB
JavaScript
1908 lines
68 KiB
JavaScript
import {
|
|
capitalize_exports,
|
|
deepmerge_exports,
|
|
defaultTheme_default,
|
|
getDisplayName_exports,
|
|
identifier_default,
|
|
init_capitalize,
|
|
init_deepmerge,
|
|
init_getDisplayName,
|
|
init_styled_engine,
|
|
require_interopRequireDefault,
|
|
require_prop_types,
|
|
styled_engine_exports
|
|
} from "./chunk-QLKRFDUE.js";
|
|
import {
|
|
__commonJS,
|
|
__toCommonJS,
|
|
__toESM
|
|
} from "./chunk-HXA6O6EE.js";
|
|
|
|
// node_modules/@babel/runtime/helpers/extends.js
|
|
var require_extends = __commonJS({
|
|
"node_modules/@babel/runtime/helpers/extends.js"(exports, module) {
|
|
function _extends() {
|
|
return module.exports = _extends = Object.assign ? Object.assign.bind() : function(n) {
|
|
for (var e = 1; e < arguments.length; e++) {
|
|
var t = arguments[e];
|
|
for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
|
|
}
|
|
return n;
|
|
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
|
|
}
|
|
module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
}
|
|
});
|
|
|
|
// node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js
|
|
var require_objectWithoutPropertiesLoose = __commonJS({
|
|
"node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js"(exports, module) {
|
|
function _objectWithoutPropertiesLoose(r, e) {
|
|
if (null == r) return {};
|
|
var t = {};
|
|
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
|
|
if (-1 !== e.indexOf(n)) continue;
|
|
t[n] = r[n];
|
|
}
|
|
return t;
|
|
}
|
|
module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createTheme/createBreakpoints.js
|
|
var require_createBreakpoints = __commonJS({
|
|
"node_modules/@mui/system/createTheme/createBreakpoints.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.breakpointKeys = void 0;
|
|
exports.default = createBreakpoints;
|
|
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require_objectWithoutPropertiesLoose());
|
|
var _extends2 = _interopRequireDefault(require_extends());
|
|
var _excluded = ["values", "unit", "step"];
|
|
var breakpointKeys = exports.breakpointKeys = ["xs", "sm", "md", "lg", "xl"];
|
|
var sortBreakpointsValues = (values) => {
|
|
const breakpointsAsArray = Object.keys(values).map((key) => ({
|
|
key,
|
|
val: values[key]
|
|
})) || [];
|
|
breakpointsAsArray.sort((breakpoint1, breakpoint2) => breakpoint1.val - breakpoint2.val);
|
|
return breakpointsAsArray.reduce((acc, obj) => {
|
|
return (0, _extends2.default)({}, acc, {
|
|
[obj.key]: obj.val
|
|
});
|
|
}, {});
|
|
};
|
|
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 = (0, _objectWithoutPropertiesLoose2.default)(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) {
|
|
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 (0, _extends2.default)({
|
|
keys,
|
|
values: sortedValues,
|
|
up,
|
|
down,
|
|
between,
|
|
only,
|
|
not,
|
|
unit
|
|
}, other);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createTheme/shape.js
|
|
var require_shape = __commonJS({
|
|
"node_modules/@mui/system/createTheme/shape.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var shape = {
|
|
borderRadius: 4
|
|
};
|
|
var _default = exports.default = shape;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/responsivePropType.js
|
|
var require_responsivePropType = __commonJS({
|
|
"node_modules/@mui/system/responsivePropType.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var _propTypes = _interopRequireDefault(require_prop_types());
|
|
var responsivePropType = true ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string, _propTypes.default.object, _propTypes.default.array]) : {};
|
|
var _default = exports.default = responsivePropType;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/merge.js
|
|
var require_merge = __commonJS({
|
|
"node_modules/@mui/system/merge.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var _deepmerge = _interopRequireDefault((init_deepmerge(), __toCommonJS(deepmerge_exports)));
|
|
function merge(acc, item) {
|
|
if (!item) {
|
|
return acc;
|
|
}
|
|
return (0, _deepmerge.default)(acc, item, {
|
|
clone: false
|
|
// No need to clone deep, it's way faster.
|
|
});
|
|
}
|
|
var _default = exports.default = merge;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/breakpoints.js
|
|
var require_breakpoints = __commonJS({
|
|
"node_modules/@mui/system/breakpoints.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.computeBreakpointsBase = computeBreakpointsBase;
|
|
exports.createEmptyBreakpointObject = createEmptyBreakpointObject;
|
|
exports.default = void 0;
|
|
exports.handleBreakpoints = handleBreakpoints;
|
|
exports.mergeBreakpointsInOrder = mergeBreakpointsInOrder;
|
|
exports.removeUnusedBreakpoints = removeUnusedBreakpoints;
|
|
exports.resolveBreakpointValues = resolveBreakpointValues;
|
|
exports.values = void 0;
|
|
var _extends2 = _interopRequireDefault(require_extends());
|
|
var _propTypes = _interopRequireDefault(require_prop_types());
|
|
var _deepmerge = _interopRequireDefault((init_deepmerge(), __toCommonJS(deepmerge_exports)));
|
|
var _merge = _interopRequireDefault(require_merge());
|
|
var values = exports.values = {
|
|
xs: 0,
|
|
// phone
|
|
sm: 600,
|
|
// tablet
|
|
md: 900,
|
|
// small laptop
|
|
lg: 1200,
|
|
// desktop
|
|
xl: 1536
|
|
// large screen
|
|
};
|
|
var 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) => {
|
|
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 breakpoints(styleFunction) {
|
|
const newStyleFunction = (props) => {
|
|
const theme = props.theme || {};
|
|
const base = styleFunction(props);
|
|
const themeBreakpoints = theme.breakpoints || defaultBreakpoints;
|
|
const extended = themeBreakpoints.keys.reduce((acc, key) => {
|
|
if (props[key]) {
|
|
acc = acc || {};
|
|
acc[themeBreakpoints.up(key)] = styleFunction((0, _extends2.default)({
|
|
theme
|
|
}, props[key]));
|
|
}
|
|
return acc;
|
|
}, null);
|
|
return (0, _merge.default)(base, extended);
|
|
};
|
|
newStyleFunction.propTypes = true ? (0, _extends2.default)({}, styleFunction.propTypes, {
|
|
xs: _propTypes.default.object,
|
|
sm: _propTypes.default.object,
|
|
md: _propTypes.default.object,
|
|
lg: _propTypes.default.object,
|
|
xl: _propTypes.default.object
|
|
}) : {};
|
|
newStyleFunction.filterProps = ["xs", "sm", "md", "lg", "xl", ...styleFunction.filterProps];
|
|
return newStyleFunction;
|
|
}
|
|
function createEmptyBreakpointObject(breakpointsInput = {}) {
|
|
var _breakpointsInput$key;
|
|
const breakpointsInOrder = (_breakpointsInput$key = breakpointsInput.keys) == null ? void 0 : _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);
|
|
}
|
|
function mergeBreakpointsInOrder(breakpointsInput, ...styles) {
|
|
const emptyBreakpoints = createEmptyBreakpointObject(breakpointsInput);
|
|
const mergedOutput = [emptyBreakpoints, ...styles].reduce((prev, next) => (0, _deepmerge.default)(prev, next), {});
|
|
return removeUnusedBreakpoints(Object.keys(emptyBreakpoints), mergedOutput);
|
|
}
|
|
function computeBreakpointsBase(breakpointValues, themeBreakpoints) {
|
|
if (typeof breakpointValues !== "object") {
|
|
return {};
|
|
}
|
|
const base = {};
|
|
const breakpointsKeys = Object.keys(themeBreakpoints);
|
|
if (Array.isArray(breakpointValues)) {
|
|
breakpointsKeys.forEach((breakpoint, i) => {
|
|
if (i < breakpointValues.length) {
|
|
base[breakpoint] = true;
|
|
}
|
|
});
|
|
} else {
|
|
breakpointsKeys.forEach((breakpoint) => {
|
|
if (breakpointValues[breakpoint] != null) {
|
|
base[breakpoint] = true;
|
|
}
|
|
});
|
|
}
|
|
return base;
|
|
}
|
|
function resolveBreakpointValues({
|
|
values: breakpointValues,
|
|
breakpoints: themeBreakpoints,
|
|
base: customBase
|
|
}) {
|
|
const base = customBase || computeBreakpointsBase(breakpointValues, themeBreakpoints);
|
|
const keys = Object.keys(base);
|
|
if (keys.length === 0) {
|
|
return breakpointValues;
|
|
}
|
|
let previous;
|
|
return keys.reduce((acc, breakpoint, i) => {
|
|
if (Array.isArray(breakpointValues)) {
|
|
acc[breakpoint] = breakpointValues[i] != null ? breakpointValues[i] : breakpointValues[previous];
|
|
previous = i;
|
|
} else if (typeof breakpointValues === "object") {
|
|
acc[breakpoint] = breakpointValues[breakpoint] != null ? breakpointValues[breakpoint] : breakpointValues[previous];
|
|
previous = breakpoint;
|
|
} else {
|
|
acc[breakpoint] = breakpointValues;
|
|
}
|
|
return acc;
|
|
}, {});
|
|
}
|
|
var _default = exports.default = breakpoints;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/style.js
|
|
var require_style = __commonJS({
|
|
"node_modules/@mui/system/style.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
exports.getPath = getPath;
|
|
exports.getStyleValue = getStyleValue;
|
|
var _capitalize = _interopRequireDefault((init_capitalize(), __toCommonJS(capitalize_exports)));
|
|
var _responsivePropType = _interopRequireDefault(require_responsivePropType());
|
|
var _breakpoints = require_breakpoints();
|
|
function getPath(obj, path, checkVars = true) {
|
|
if (!path || typeof path !== "string") {
|
|
return null;
|
|
}
|
|
if (obj && obj.vars && checkVars) {
|
|
const val = `vars.${path}`.split(".").reduce((acc, item) => acc && acc[item] ? acc[item] : null, obj);
|
|
if (val != null) {
|
|
return val;
|
|
}
|
|
}
|
|
return path.split(".").reduce((acc, item) => {
|
|
if (acc && acc[item] != null) {
|
|
return acc[item];
|
|
}
|
|
return null;
|
|
}, obj);
|
|
}
|
|
function getStyleValue(themeMapping, transform, propValueFinal, userValue = propValueFinal) {
|
|
let value;
|
|
if (typeof themeMapping === "function") {
|
|
value = themeMapping(propValueFinal);
|
|
} else if (Array.isArray(themeMapping)) {
|
|
value = themeMapping[propValueFinal] || userValue;
|
|
} else {
|
|
value = getPath(themeMapping, propValueFinal) || userValue;
|
|
}
|
|
if (transform) {
|
|
value = transform(value, userValue, themeMapping);
|
|
}
|
|
return value;
|
|
}
|
|
function style(options) {
|
|
const {
|
|
prop,
|
|
cssProperty = options.prop,
|
|
themeKey,
|
|
transform
|
|
} = options;
|
|
const fn = (props) => {
|
|
if (props[prop] == null) {
|
|
return null;
|
|
}
|
|
const propValue = props[prop];
|
|
const theme = props.theme;
|
|
const themeMapping = getPath(theme, themeKey) || {};
|
|
const styleFromPropValue = (propValueFinal) => {
|
|
let value = getStyleValue(themeMapping, transform, propValueFinal);
|
|
if (propValueFinal === value && typeof propValueFinal === "string") {
|
|
value = getStyleValue(themeMapping, transform, `${prop}${propValueFinal === "default" ? "" : (0, _capitalize.default)(propValueFinal)}`, propValueFinal);
|
|
}
|
|
if (cssProperty === false) {
|
|
return value;
|
|
}
|
|
return {
|
|
[cssProperty]: value
|
|
};
|
|
};
|
|
return (0, _breakpoints.handleBreakpoints)(props, propValue, styleFromPropValue);
|
|
};
|
|
fn.propTypes = true ? {
|
|
[prop]: _responsivePropType.default
|
|
} : {};
|
|
fn.filterProps = [prop];
|
|
return fn;
|
|
}
|
|
var _default = exports.default = style;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/memoize.js
|
|
var require_memoize = __commonJS({
|
|
"node_modules/@mui/system/memoize.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = memoize;
|
|
function memoize(fn) {
|
|
const cache = {};
|
|
return (arg) => {
|
|
if (cache[arg] === void 0) {
|
|
cache[arg] = fn(arg);
|
|
}
|
|
return cache[arg];
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/spacing.js
|
|
var require_spacing = __commonJS({
|
|
"node_modules/@mui/system/spacing.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.createUnarySpacing = createUnarySpacing;
|
|
exports.createUnaryUnit = createUnaryUnit;
|
|
exports.default = void 0;
|
|
exports.getStyleFromPropValue = getStyleFromPropValue;
|
|
exports.getValue = getValue;
|
|
exports.margin = margin;
|
|
exports.marginKeys = void 0;
|
|
exports.padding = padding;
|
|
exports.paddingKeys = void 0;
|
|
var _responsivePropType = _interopRequireDefault(require_responsivePropType());
|
|
var _breakpoints = require_breakpoints();
|
|
var _style = require_style();
|
|
var _merge = _interopRequireDefault(require_merge());
|
|
var _memoize = _interopRequireDefault(require_memoize());
|
|
var properties = {
|
|
m: "margin",
|
|
p: "padding"
|
|
};
|
|
var directions = {
|
|
t: "Top",
|
|
r: "Right",
|
|
b: "Bottom",
|
|
l: "Left",
|
|
x: ["Left", "Right"],
|
|
y: ["Top", "Bottom"]
|
|
};
|
|
var aliases = {
|
|
marginX: "mx",
|
|
marginY: "my",
|
|
paddingX: "px",
|
|
paddingY: "py"
|
|
};
|
|
var getCssProperties = (0, _memoize.default)((prop) => {
|
|
if (prop.length > 2) {
|
|
if (aliases[prop]) {
|
|
prop = aliases[prop];
|
|
} else {
|
|
return [prop];
|
|
}
|
|
}
|
|
const [a, b] = prop.split("");
|
|
const property = properties[a];
|
|
const direction = directions[b] || "";
|
|
return Array.isArray(direction) ? direction.map((dir) => property + dir) : [property + direction];
|
|
});
|
|
var marginKeys = exports.marginKeys = ["m", "mt", "mr", "mb", "ml", "mx", "my", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "marginX", "marginY", "marginInline", "marginInlineStart", "marginInlineEnd", "marginBlock", "marginBlockStart", "marginBlockEnd"];
|
|
var paddingKeys = exports.paddingKeys = ["p", "pt", "pr", "pb", "pl", "px", "py", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "paddingX", "paddingY", "paddingInline", "paddingInlineStart", "paddingInlineEnd", "paddingBlock", "paddingBlockStart", "paddingBlockEnd"];
|
|
var spacingKeys = [...marginKeys, ...paddingKeys];
|
|
function createUnaryUnit(theme, themeKey, defaultValue, propName) {
|
|
var _getPath;
|
|
const themeSpacing = (_getPath = (0, _style.getPath)(theme, themeKey, false)) != null ? _getPath : defaultValue;
|
|
if (typeof themeSpacing === "number") {
|
|
return (abs) => {
|
|
if (typeof abs === "string") {
|
|
return abs;
|
|
}
|
|
if (true) {
|
|
if (typeof abs !== "number") {
|
|
console.error(`MUI: Expected ${propName} argument to be a number or a string, got ${abs}.`);
|
|
}
|
|
}
|
|
return themeSpacing * abs;
|
|
};
|
|
}
|
|
if (Array.isArray(themeSpacing)) {
|
|
return (abs) => {
|
|
if (typeof abs === "string") {
|
|
return abs;
|
|
}
|
|
if (true) {
|
|
if (!Number.isInteger(abs)) {
|
|
console.error([`MUI: The \`theme.${themeKey}\` array type cannot be combined with non integer values.You should either use an integer value that can be used as index, or define the \`theme.${themeKey}\` as a number.`].join("\n"));
|
|
} else if (abs > themeSpacing.length - 1) {
|
|
console.error([`MUI: The value provided (${abs}) overflows.`, `The supported values are: ${JSON.stringify(themeSpacing)}.`, `${abs} > ${themeSpacing.length - 1}, you need to add the missing values.`].join("\n"));
|
|
}
|
|
}
|
|
return themeSpacing[abs];
|
|
};
|
|
}
|
|
if (typeof themeSpacing === "function") {
|
|
return themeSpacing;
|
|
}
|
|
if (true) {
|
|
console.error([`MUI: The \`theme.${themeKey}\` value (${themeSpacing}) is invalid.`, "It should be a number, an array or a function."].join("\n"));
|
|
}
|
|
return () => void 0;
|
|
}
|
|
function createUnarySpacing(theme) {
|
|
return createUnaryUnit(theme, "spacing", 8, "spacing");
|
|
}
|
|
function getValue(transformer, propValue) {
|
|
if (typeof propValue === "string" || propValue == null) {
|
|
return propValue;
|
|
}
|
|
const abs = Math.abs(propValue);
|
|
const transformed = transformer(abs);
|
|
if (propValue >= 0) {
|
|
return transformed;
|
|
}
|
|
if (typeof transformed === "number") {
|
|
return -transformed;
|
|
}
|
|
return `-${transformed}`;
|
|
}
|
|
function getStyleFromPropValue(cssProperties, transformer) {
|
|
return (propValue) => cssProperties.reduce((acc, cssProperty) => {
|
|
acc[cssProperty] = getValue(transformer, propValue);
|
|
return acc;
|
|
}, {});
|
|
}
|
|
function resolveCssProperty(props, keys, prop, transformer) {
|
|
if (keys.indexOf(prop) === -1) {
|
|
return null;
|
|
}
|
|
const cssProperties = getCssProperties(prop);
|
|
const styleFromPropValue = getStyleFromPropValue(cssProperties, transformer);
|
|
const propValue = props[prop];
|
|
return (0, _breakpoints.handleBreakpoints)(props, propValue, styleFromPropValue);
|
|
}
|
|
function style(props, keys) {
|
|
const transformer = createUnarySpacing(props.theme);
|
|
return Object.keys(props).map((prop) => resolveCssProperty(props, keys, prop, transformer)).reduce(_merge.default, {});
|
|
}
|
|
function margin(props) {
|
|
return style(props, marginKeys);
|
|
}
|
|
margin.propTypes = true ? marginKeys.reduce((obj, key) => {
|
|
obj[key] = _responsivePropType.default;
|
|
return obj;
|
|
}, {}) : {};
|
|
margin.filterProps = marginKeys;
|
|
function padding(props) {
|
|
return style(props, paddingKeys);
|
|
}
|
|
padding.propTypes = true ? paddingKeys.reduce((obj, key) => {
|
|
obj[key] = _responsivePropType.default;
|
|
return obj;
|
|
}, {}) : {};
|
|
padding.filterProps = paddingKeys;
|
|
function spacing(props) {
|
|
return style(props, spacingKeys);
|
|
}
|
|
spacing.propTypes = true ? spacingKeys.reduce((obj, key) => {
|
|
obj[key] = _responsivePropType.default;
|
|
return obj;
|
|
}, {}) : {};
|
|
spacing.filterProps = spacingKeys;
|
|
var _default = exports.default = spacing;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createTheme/createSpacing.js
|
|
var require_createSpacing = __commonJS({
|
|
"node_modules/@mui/system/createTheme/createSpacing.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = createSpacing;
|
|
var _spacing = require_spacing();
|
|
function createSpacing(spacingInput = 8) {
|
|
if (spacingInput.mui) {
|
|
return spacingInput;
|
|
}
|
|
const transform = (0, _spacing.createUnarySpacing)({
|
|
spacing: spacingInput
|
|
});
|
|
const spacing = (...argsInput) => {
|
|
if (true) {
|
|
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.mui = true;
|
|
return spacing;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/compose.js
|
|
var require_compose = __commonJS({
|
|
"node_modules/@mui/system/compose.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var _merge = _interopRequireDefault(require_merge());
|
|
function compose(...styles) {
|
|
const handlers = styles.reduce((acc, style) => {
|
|
style.filterProps.forEach((prop) => {
|
|
acc[prop] = style;
|
|
});
|
|
return acc;
|
|
}, {});
|
|
const fn = (props) => {
|
|
return Object.keys(props).reduce((acc, prop) => {
|
|
if (handlers[prop]) {
|
|
return (0, _merge.default)(acc, handlers[prop](props));
|
|
}
|
|
return acc;
|
|
}, {});
|
|
};
|
|
fn.propTypes = true ? styles.reduce((acc, style) => Object.assign(acc, style.propTypes), {}) : {};
|
|
fn.filterProps = styles.reduce((acc, style) => acc.concat(style.filterProps), []);
|
|
return fn;
|
|
}
|
|
var _default = exports.default = compose;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/borders.js
|
|
var require_borders = __commonJS({
|
|
"node_modules/@mui/system/borders.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.borderTopColor = exports.borderTop = exports.borderRightColor = exports.borderRight = exports.borderRadius = exports.borderLeftColor = exports.borderLeft = exports.borderColor = exports.borderBottomColor = exports.borderBottom = exports.border = void 0;
|
|
exports.borderTransform = borderTransform;
|
|
exports.outlineColor = exports.outline = exports.default = void 0;
|
|
var _responsivePropType = _interopRequireDefault(require_responsivePropType());
|
|
var _style = _interopRequireDefault(require_style());
|
|
var _compose = _interopRequireDefault(require_compose());
|
|
var _spacing = require_spacing();
|
|
var _breakpoints = require_breakpoints();
|
|
function borderTransform(value) {
|
|
if (typeof value !== "number") {
|
|
return value;
|
|
}
|
|
return `${value}px solid`;
|
|
}
|
|
function createBorderStyle(prop, transform) {
|
|
return (0, _style.default)({
|
|
prop,
|
|
themeKey: "borders",
|
|
transform
|
|
});
|
|
}
|
|
var border = exports.border = createBorderStyle("border", borderTransform);
|
|
var borderTop = exports.borderTop = createBorderStyle("borderTop", borderTransform);
|
|
var borderRight = exports.borderRight = createBorderStyle("borderRight", borderTransform);
|
|
var borderBottom = exports.borderBottom = createBorderStyle("borderBottom", borderTransform);
|
|
var borderLeft = exports.borderLeft = createBorderStyle("borderLeft", borderTransform);
|
|
var borderColor = exports.borderColor = createBorderStyle("borderColor");
|
|
var borderTopColor = exports.borderTopColor = createBorderStyle("borderTopColor");
|
|
var borderRightColor = exports.borderRightColor = createBorderStyle("borderRightColor");
|
|
var borderBottomColor = exports.borderBottomColor = createBorderStyle("borderBottomColor");
|
|
var borderLeftColor = exports.borderLeftColor = createBorderStyle("borderLeftColor");
|
|
var outline = exports.outline = createBorderStyle("outline", borderTransform);
|
|
var outlineColor = exports.outlineColor = createBorderStyle("outlineColor");
|
|
var borderRadius = (props) => {
|
|
if (props.borderRadius !== void 0 && props.borderRadius !== null) {
|
|
const transformer = (0, _spacing.createUnaryUnit)(props.theme, "shape.borderRadius", 4, "borderRadius");
|
|
const styleFromPropValue = (propValue) => ({
|
|
borderRadius: (0, _spacing.getValue)(transformer, propValue)
|
|
});
|
|
return (0, _breakpoints.handleBreakpoints)(props, props.borderRadius, styleFromPropValue);
|
|
}
|
|
return null;
|
|
};
|
|
exports.borderRadius = borderRadius;
|
|
borderRadius.propTypes = true ? {
|
|
borderRadius: _responsivePropType.default
|
|
} : {};
|
|
borderRadius.filterProps = ["borderRadius"];
|
|
var borders = (0, _compose.default)(border, borderTop, borderRight, borderBottom, borderLeft, borderColor, borderTopColor, borderRightColor, borderBottomColor, borderLeftColor, borderRadius, outline, outlineColor);
|
|
var _default = exports.default = borders;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/cssGrid.js
|
|
var require_cssGrid = __commonJS({
|
|
"node_modules/@mui/system/cssGrid.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.rowGap = exports.gridTemplateRows = exports.gridTemplateColumns = exports.gridTemplateAreas = exports.gridRow = exports.gridColumn = exports.gridAutoRows = exports.gridAutoFlow = exports.gridAutoColumns = exports.gridArea = exports.gap = exports.default = exports.columnGap = void 0;
|
|
var _style = _interopRequireDefault(require_style());
|
|
var _compose = _interopRequireDefault(require_compose());
|
|
var _spacing = require_spacing();
|
|
var _breakpoints = require_breakpoints();
|
|
var _responsivePropType = _interopRequireDefault(require_responsivePropType());
|
|
var gap = (props) => {
|
|
if (props.gap !== void 0 && props.gap !== null) {
|
|
const transformer = (0, _spacing.createUnaryUnit)(props.theme, "spacing", 8, "gap");
|
|
const styleFromPropValue = (propValue) => ({
|
|
gap: (0, _spacing.getValue)(transformer, propValue)
|
|
});
|
|
return (0, _breakpoints.handleBreakpoints)(props, props.gap, styleFromPropValue);
|
|
}
|
|
return null;
|
|
};
|
|
exports.gap = gap;
|
|
gap.propTypes = true ? {
|
|
gap: _responsivePropType.default
|
|
} : {};
|
|
gap.filterProps = ["gap"];
|
|
var columnGap = (props) => {
|
|
if (props.columnGap !== void 0 && props.columnGap !== null) {
|
|
const transformer = (0, _spacing.createUnaryUnit)(props.theme, "spacing", 8, "columnGap");
|
|
const styleFromPropValue = (propValue) => ({
|
|
columnGap: (0, _spacing.getValue)(transformer, propValue)
|
|
});
|
|
return (0, _breakpoints.handleBreakpoints)(props, props.columnGap, styleFromPropValue);
|
|
}
|
|
return null;
|
|
};
|
|
exports.columnGap = columnGap;
|
|
columnGap.propTypes = true ? {
|
|
columnGap: _responsivePropType.default
|
|
} : {};
|
|
columnGap.filterProps = ["columnGap"];
|
|
var rowGap = (props) => {
|
|
if (props.rowGap !== void 0 && props.rowGap !== null) {
|
|
const transformer = (0, _spacing.createUnaryUnit)(props.theme, "spacing", 8, "rowGap");
|
|
const styleFromPropValue = (propValue) => ({
|
|
rowGap: (0, _spacing.getValue)(transformer, propValue)
|
|
});
|
|
return (0, _breakpoints.handleBreakpoints)(props, props.rowGap, styleFromPropValue);
|
|
}
|
|
return null;
|
|
};
|
|
exports.rowGap = rowGap;
|
|
rowGap.propTypes = true ? {
|
|
rowGap: _responsivePropType.default
|
|
} : {};
|
|
rowGap.filterProps = ["rowGap"];
|
|
var gridColumn = exports.gridColumn = (0, _style.default)({
|
|
prop: "gridColumn"
|
|
});
|
|
var gridRow = exports.gridRow = (0, _style.default)({
|
|
prop: "gridRow"
|
|
});
|
|
var gridAutoFlow = exports.gridAutoFlow = (0, _style.default)({
|
|
prop: "gridAutoFlow"
|
|
});
|
|
var gridAutoColumns = exports.gridAutoColumns = (0, _style.default)({
|
|
prop: "gridAutoColumns"
|
|
});
|
|
var gridAutoRows = exports.gridAutoRows = (0, _style.default)({
|
|
prop: "gridAutoRows"
|
|
});
|
|
var gridTemplateColumns = exports.gridTemplateColumns = (0, _style.default)({
|
|
prop: "gridTemplateColumns"
|
|
});
|
|
var gridTemplateRows = exports.gridTemplateRows = (0, _style.default)({
|
|
prop: "gridTemplateRows"
|
|
});
|
|
var gridTemplateAreas = exports.gridTemplateAreas = (0, _style.default)({
|
|
prop: "gridTemplateAreas"
|
|
});
|
|
var gridArea = exports.gridArea = (0, _style.default)({
|
|
prop: "gridArea"
|
|
});
|
|
var grid = (0, _compose.default)(gap, columnGap, rowGap, gridColumn, gridRow, gridAutoFlow, gridAutoColumns, gridAutoRows, gridTemplateColumns, gridTemplateRows, gridTemplateAreas, gridArea);
|
|
var _default = exports.default = grid;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/palette.js
|
|
var require_palette = __commonJS({
|
|
"node_modules/@mui/system/palette.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.color = exports.bgcolor = exports.backgroundColor = void 0;
|
|
exports.paletteTransform = paletteTransform;
|
|
var _style = _interopRequireDefault(require_style());
|
|
var _compose = _interopRequireDefault(require_compose());
|
|
function paletteTransform(value, userValue) {
|
|
if (userValue === "grey") {
|
|
return userValue;
|
|
}
|
|
return value;
|
|
}
|
|
var color = exports.color = (0, _style.default)({
|
|
prop: "color",
|
|
themeKey: "palette",
|
|
transform: paletteTransform
|
|
});
|
|
var bgcolor = exports.bgcolor = (0, _style.default)({
|
|
prop: "bgcolor",
|
|
cssProperty: "backgroundColor",
|
|
themeKey: "palette",
|
|
transform: paletteTransform
|
|
});
|
|
var backgroundColor = exports.backgroundColor = (0, _style.default)({
|
|
prop: "backgroundColor",
|
|
themeKey: "palette",
|
|
transform: paletteTransform
|
|
});
|
|
var palette = (0, _compose.default)(color, bgcolor, backgroundColor);
|
|
var _default = exports.default = palette;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/sizing.js
|
|
var require_sizing = __commonJS({
|
|
"node_modules/@mui/system/sizing.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.sizeWidth = exports.sizeHeight = exports.minWidth = exports.minHeight = exports.maxWidth = exports.maxHeight = exports.height = exports.default = exports.boxSizing = void 0;
|
|
exports.sizingTransform = sizingTransform;
|
|
exports.width = void 0;
|
|
var _style = _interopRequireDefault(require_style());
|
|
var _compose = _interopRequireDefault(require_compose());
|
|
var _breakpoints = require_breakpoints();
|
|
function sizingTransform(value) {
|
|
return value <= 1 && value !== 0 ? `${value * 100}%` : value;
|
|
}
|
|
var width = exports.width = (0, _style.default)({
|
|
prop: "width",
|
|
transform: sizingTransform
|
|
});
|
|
var maxWidth = (props) => {
|
|
if (props.maxWidth !== void 0 && props.maxWidth !== null) {
|
|
const styleFromPropValue = (propValue) => {
|
|
var _props$theme, _props$theme2;
|
|
const breakpoint = ((_props$theme = props.theme) == null || (_props$theme = _props$theme.breakpoints) == null || (_props$theme = _props$theme.values) == null ? void 0 : _props$theme[propValue]) || _breakpoints.values[propValue];
|
|
if (!breakpoint) {
|
|
return {
|
|
maxWidth: sizingTransform(propValue)
|
|
};
|
|
}
|
|
if (((_props$theme2 = props.theme) == null || (_props$theme2 = _props$theme2.breakpoints) == null ? void 0 : _props$theme2.unit) !== "px") {
|
|
return {
|
|
maxWidth: `${breakpoint}${props.theme.breakpoints.unit}`
|
|
};
|
|
}
|
|
return {
|
|
maxWidth: breakpoint
|
|
};
|
|
};
|
|
return (0, _breakpoints.handleBreakpoints)(props, props.maxWidth, styleFromPropValue);
|
|
}
|
|
return null;
|
|
};
|
|
exports.maxWidth = maxWidth;
|
|
maxWidth.filterProps = ["maxWidth"];
|
|
var minWidth = exports.minWidth = (0, _style.default)({
|
|
prop: "minWidth",
|
|
transform: sizingTransform
|
|
});
|
|
var height = exports.height = (0, _style.default)({
|
|
prop: "height",
|
|
transform: sizingTransform
|
|
});
|
|
var maxHeight = exports.maxHeight = (0, _style.default)({
|
|
prop: "maxHeight",
|
|
transform: sizingTransform
|
|
});
|
|
var minHeight = exports.minHeight = (0, _style.default)({
|
|
prop: "minHeight",
|
|
transform: sizingTransform
|
|
});
|
|
var sizeWidth = exports.sizeWidth = (0, _style.default)({
|
|
prop: "size",
|
|
cssProperty: "width",
|
|
transform: sizingTransform
|
|
});
|
|
var sizeHeight = exports.sizeHeight = (0, _style.default)({
|
|
prop: "size",
|
|
cssProperty: "height",
|
|
transform: sizingTransform
|
|
});
|
|
var boxSizing = exports.boxSizing = (0, _style.default)({
|
|
prop: "boxSizing"
|
|
});
|
|
var sizing = (0, _compose.default)(width, maxWidth, minWidth, height, maxHeight, minHeight, boxSizing);
|
|
var _default = exports.default = sizing;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/styleFunctionSx/defaultSxConfig.js
|
|
var require_defaultSxConfig = __commonJS({
|
|
"node_modules/@mui/system/styleFunctionSx/defaultSxConfig.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var _spacing = require_spacing();
|
|
var _borders = require_borders();
|
|
var _cssGrid = require_cssGrid();
|
|
var _palette = require_palette();
|
|
var _sizing = require_sizing();
|
|
var defaultSxConfig = {
|
|
// borders
|
|
border: {
|
|
themeKey: "borders",
|
|
transform: _borders.borderTransform
|
|
},
|
|
borderTop: {
|
|
themeKey: "borders",
|
|
transform: _borders.borderTransform
|
|
},
|
|
borderRight: {
|
|
themeKey: "borders",
|
|
transform: _borders.borderTransform
|
|
},
|
|
borderBottom: {
|
|
themeKey: "borders",
|
|
transform: _borders.borderTransform
|
|
},
|
|
borderLeft: {
|
|
themeKey: "borders",
|
|
transform: _borders.borderTransform
|
|
},
|
|
borderColor: {
|
|
themeKey: "palette"
|
|
},
|
|
borderTopColor: {
|
|
themeKey: "palette"
|
|
},
|
|
borderRightColor: {
|
|
themeKey: "palette"
|
|
},
|
|
borderBottomColor: {
|
|
themeKey: "palette"
|
|
},
|
|
borderLeftColor: {
|
|
themeKey: "palette"
|
|
},
|
|
outline: {
|
|
themeKey: "borders",
|
|
transform: _borders.borderTransform
|
|
},
|
|
outlineColor: {
|
|
themeKey: "palette"
|
|
},
|
|
borderRadius: {
|
|
themeKey: "shape.borderRadius",
|
|
style: _borders.borderRadius
|
|
},
|
|
// palette
|
|
color: {
|
|
themeKey: "palette",
|
|
transform: _palette.paletteTransform
|
|
},
|
|
bgcolor: {
|
|
themeKey: "palette",
|
|
cssProperty: "backgroundColor",
|
|
transform: _palette.paletteTransform
|
|
},
|
|
backgroundColor: {
|
|
themeKey: "palette",
|
|
transform: _palette.paletteTransform
|
|
},
|
|
// spacing
|
|
p: {
|
|
style: _spacing.padding
|
|
},
|
|
pt: {
|
|
style: _spacing.padding
|
|
},
|
|
pr: {
|
|
style: _spacing.padding
|
|
},
|
|
pb: {
|
|
style: _spacing.padding
|
|
},
|
|
pl: {
|
|
style: _spacing.padding
|
|
},
|
|
px: {
|
|
style: _spacing.padding
|
|
},
|
|
py: {
|
|
style: _spacing.padding
|
|
},
|
|
padding: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingTop: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingRight: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingBottom: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingLeft: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingX: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingY: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingInline: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingInlineStart: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingInlineEnd: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingBlock: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingBlockStart: {
|
|
style: _spacing.padding
|
|
},
|
|
paddingBlockEnd: {
|
|
style: _spacing.padding
|
|
},
|
|
m: {
|
|
style: _spacing.margin
|
|
},
|
|
mt: {
|
|
style: _spacing.margin
|
|
},
|
|
mr: {
|
|
style: _spacing.margin
|
|
},
|
|
mb: {
|
|
style: _spacing.margin
|
|
},
|
|
ml: {
|
|
style: _spacing.margin
|
|
},
|
|
mx: {
|
|
style: _spacing.margin
|
|
},
|
|
my: {
|
|
style: _spacing.margin
|
|
},
|
|
margin: {
|
|
style: _spacing.margin
|
|
},
|
|
marginTop: {
|
|
style: _spacing.margin
|
|
},
|
|
marginRight: {
|
|
style: _spacing.margin
|
|
},
|
|
marginBottom: {
|
|
style: _spacing.margin
|
|
},
|
|
marginLeft: {
|
|
style: _spacing.margin
|
|
},
|
|
marginX: {
|
|
style: _spacing.margin
|
|
},
|
|
marginY: {
|
|
style: _spacing.margin
|
|
},
|
|
marginInline: {
|
|
style: _spacing.margin
|
|
},
|
|
marginInlineStart: {
|
|
style: _spacing.margin
|
|
},
|
|
marginInlineEnd: {
|
|
style: _spacing.margin
|
|
},
|
|
marginBlock: {
|
|
style: _spacing.margin
|
|
},
|
|
marginBlockStart: {
|
|
style: _spacing.margin
|
|
},
|
|
marginBlockEnd: {
|
|
style: _spacing.margin
|
|
},
|
|
// display
|
|
displayPrint: {
|
|
cssProperty: false,
|
|
transform: (value) => ({
|
|
"@media print": {
|
|
display: value
|
|
}
|
|
})
|
|
},
|
|
display: {},
|
|
overflow: {},
|
|
textOverflow: {},
|
|
visibility: {},
|
|
whiteSpace: {},
|
|
// flexbox
|
|
flexBasis: {},
|
|
flexDirection: {},
|
|
flexWrap: {},
|
|
justifyContent: {},
|
|
alignItems: {},
|
|
alignContent: {},
|
|
order: {},
|
|
flex: {},
|
|
flexGrow: {},
|
|
flexShrink: {},
|
|
alignSelf: {},
|
|
justifyItems: {},
|
|
justifySelf: {},
|
|
// grid
|
|
gap: {
|
|
style: _cssGrid.gap
|
|
},
|
|
rowGap: {
|
|
style: _cssGrid.rowGap
|
|
},
|
|
columnGap: {
|
|
style: _cssGrid.columnGap
|
|
},
|
|
gridColumn: {},
|
|
gridRow: {},
|
|
gridAutoFlow: {},
|
|
gridAutoColumns: {},
|
|
gridAutoRows: {},
|
|
gridTemplateColumns: {},
|
|
gridTemplateRows: {},
|
|
gridTemplateAreas: {},
|
|
gridArea: {},
|
|
// positions
|
|
position: {},
|
|
zIndex: {
|
|
themeKey: "zIndex"
|
|
},
|
|
top: {},
|
|
right: {},
|
|
bottom: {},
|
|
left: {},
|
|
// shadows
|
|
boxShadow: {
|
|
themeKey: "shadows"
|
|
},
|
|
// sizing
|
|
width: {
|
|
transform: _sizing.sizingTransform
|
|
},
|
|
maxWidth: {
|
|
style: _sizing.maxWidth
|
|
},
|
|
minWidth: {
|
|
transform: _sizing.sizingTransform
|
|
},
|
|
height: {
|
|
transform: _sizing.sizingTransform
|
|
},
|
|
maxHeight: {
|
|
transform: _sizing.sizingTransform
|
|
},
|
|
minHeight: {
|
|
transform: _sizing.sizingTransform
|
|
},
|
|
boxSizing: {},
|
|
// typography
|
|
fontFamily: {
|
|
themeKey: "typography"
|
|
},
|
|
fontSize: {
|
|
themeKey: "typography"
|
|
},
|
|
fontStyle: {
|
|
themeKey: "typography"
|
|
},
|
|
fontWeight: {
|
|
themeKey: "typography"
|
|
},
|
|
letterSpacing: {},
|
|
textTransform: {},
|
|
lineHeight: {},
|
|
textAlign: {},
|
|
typography: {
|
|
cssProperty: false,
|
|
themeKey: "typography"
|
|
}
|
|
};
|
|
var _default = exports.default = defaultSxConfig;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/styleFunctionSx/styleFunctionSx.js
|
|
var require_styleFunctionSx = __commonJS({
|
|
"node_modules/@mui/system/styleFunctionSx/styleFunctionSx.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
exports.unstable_createStyleFunctionSx = unstable_createStyleFunctionSx;
|
|
var _capitalize = _interopRequireDefault((init_capitalize(), __toCommonJS(capitalize_exports)));
|
|
var _merge = _interopRequireDefault(require_merge());
|
|
var _style = require_style();
|
|
var _breakpoints = require_breakpoints();
|
|
var _defaultSxConfig = _interopRequireDefault(require_defaultSxConfig());
|
|
function objectsHaveSameKeys(...objects) {
|
|
const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), []);
|
|
const union = new Set(allKeys);
|
|
return objects.every((object) => union.size === Object.keys(object).length);
|
|
}
|
|
function callIfFn(maybeFn, arg) {
|
|
return typeof maybeFn === "function" ? maybeFn(arg) : maybeFn;
|
|
}
|
|
function unstable_createStyleFunctionSx() {
|
|
function getThemeValue(prop, val, theme, config) {
|
|
const props = {
|
|
[prop]: val,
|
|
theme
|
|
};
|
|
const options = config[prop];
|
|
if (!options) {
|
|
return {
|
|
[prop]: val
|
|
};
|
|
}
|
|
const {
|
|
cssProperty = prop,
|
|
themeKey,
|
|
transform,
|
|
style
|
|
} = options;
|
|
if (val == null) {
|
|
return null;
|
|
}
|
|
if (themeKey === "typography" && val === "inherit") {
|
|
return {
|
|
[prop]: val
|
|
};
|
|
}
|
|
const themeMapping = (0, _style.getPath)(theme, themeKey) || {};
|
|
if (style) {
|
|
return style(props);
|
|
}
|
|
const styleFromPropValue = (propValueFinal) => {
|
|
let value = (0, _style.getStyleValue)(themeMapping, transform, propValueFinal);
|
|
if (propValueFinal === value && typeof propValueFinal === "string") {
|
|
value = (0, _style.getStyleValue)(themeMapping, transform, `${prop}${propValueFinal === "default" ? "" : (0, _capitalize.default)(propValueFinal)}`, propValueFinal);
|
|
}
|
|
if (cssProperty === false) {
|
|
return value;
|
|
}
|
|
return {
|
|
[cssProperty]: value
|
|
};
|
|
};
|
|
return (0, _breakpoints.handleBreakpoints)(props, val, styleFromPropValue);
|
|
}
|
|
function styleFunctionSx2(props) {
|
|
var _theme$unstable_sxCon;
|
|
const {
|
|
sx,
|
|
theme = {},
|
|
nested
|
|
} = props || {};
|
|
if (!sx) {
|
|
return null;
|
|
}
|
|
const config = (_theme$unstable_sxCon = theme.unstable_sxConfig) != null ? _theme$unstable_sxCon : _defaultSxConfig.default;
|
|
function traverse(sxInput) {
|
|
let sxObject = sxInput;
|
|
if (typeof sxInput === "function") {
|
|
sxObject = sxInput(theme);
|
|
} else if (typeof sxInput !== "object") {
|
|
return sxInput;
|
|
}
|
|
if (!sxObject) {
|
|
return null;
|
|
}
|
|
const emptyBreakpoints = (0, _breakpoints.createEmptyBreakpointObject)(theme.breakpoints);
|
|
const breakpointsKeys = Object.keys(emptyBreakpoints);
|
|
let css = emptyBreakpoints;
|
|
Object.keys(sxObject).forEach((styleKey) => {
|
|
const value = callIfFn(sxObject[styleKey], theme);
|
|
if (value !== null && value !== void 0) {
|
|
if (typeof value === "object") {
|
|
if (config[styleKey]) {
|
|
css = (0, _merge.default)(css, getThemeValue(styleKey, value, theme, config));
|
|
} else {
|
|
const breakpointsValues = (0, _breakpoints.handleBreakpoints)({
|
|
theme
|
|
}, value, (x) => ({
|
|
[styleKey]: x
|
|
}));
|
|
if (objectsHaveSameKeys(breakpointsValues, value)) {
|
|
css[styleKey] = styleFunctionSx2({
|
|
sx: value,
|
|
theme,
|
|
nested: true
|
|
});
|
|
} else {
|
|
css = (0, _merge.default)(css, breakpointsValues);
|
|
}
|
|
}
|
|
} else {
|
|
css = (0, _merge.default)(css, getThemeValue(styleKey, value, theme, config));
|
|
}
|
|
}
|
|
});
|
|
if (!nested && theme.modularCssLayers) {
|
|
return {
|
|
"@layer sx": (0, _breakpoints.removeUnusedBreakpoints)(breakpointsKeys, css)
|
|
};
|
|
}
|
|
return (0, _breakpoints.removeUnusedBreakpoints)(breakpointsKeys, css);
|
|
}
|
|
return Array.isArray(sx) ? sx.map(traverse) : traverse(sx);
|
|
}
|
|
return styleFunctionSx2;
|
|
}
|
|
var styleFunctionSx = unstable_createStyleFunctionSx();
|
|
styleFunctionSx.filterProps = ["sx"];
|
|
var _default = exports.default = styleFunctionSx;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createTheme/applyStyles.js
|
|
var require_applyStyles = __commonJS({
|
|
"node_modules/@mui/system/createTheme/applyStyles.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = applyStyles;
|
|
function applyStyles(key, styles) {
|
|
const theme = this;
|
|
if (theme.vars && typeof theme.getColorSchemeSelector === "function") {
|
|
const selector = theme.getColorSchemeSelector(key).replace(/(\[[^\]]+\])/, "*:where($1)");
|
|
return {
|
|
[selector]: styles
|
|
};
|
|
}
|
|
if (theme.palette.mode === key) {
|
|
return styles;
|
|
}
|
|
return {};
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createTheme/createTheme.js
|
|
var require_createTheme = __commonJS({
|
|
"node_modules/@mui/system/createTheme/createTheme.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var _extends2 = _interopRequireDefault(require_extends());
|
|
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require_objectWithoutPropertiesLoose());
|
|
var _deepmerge = _interopRequireDefault((init_deepmerge(), __toCommonJS(deepmerge_exports)));
|
|
var _createBreakpoints = _interopRequireDefault(require_createBreakpoints());
|
|
var _shape = _interopRequireDefault(require_shape());
|
|
var _createSpacing = _interopRequireDefault(require_createSpacing());
|
|
var _styleFunctionSx = _interopRequireDefault(require_styleFunctionSx());
|
|
var _defaultSxConfig = _interopRequireDefault(require_defaultSxConfig());
|
|
var _applyStyles = _interopRequireDefault(require_applyStyles());
|
|
var _excluded = ["breakpoints", "palette", "spacing", "shape"];
|
|
function createTheme(options = {}, ...args) {
|
|
const {
|
|
breakpoints: breakpointsInput = {},
|
|
palette: paletteInput = {},
|
|
spacing: spacingInput,
|
|
shape: shapeInput = {}
|
|
} = options, other = (0, _objectWithoutPropertiesLoose2.default)(options, _excluded);
|
|
const breakpoints = (0, _createBreakpoints.default)(breakpointsInput);
|
|
const spacing = (0, _createSpacing.default)(spacingInput);
|
|
let muiTheme = (0, _deepmerge.default)({
|
|
breakpoints,
|
|
direction: "ltr",
|
|
components: {},
|
|
// Inject component definitions.
|
|
palette: (0, _extends2.default)({
|
|
mode: "light"
|
|
}, paletteInput),
|
|
spacing,
|
|
shape: (0, _extends2.default)({}, _shape.default, shapeInput)
|
|
}, other);
|
|
muiTheme.applyStyles = _applyStyles.default;
|
|
muiTheme = args.reduce((acc, argument) => (0, _deepmerge.default)(acc, argument), muiTheme);
|
|
muiTheme.unstable_sxConfig = (0, _extends2.default)({}, _defaultSxConfig.default, other == null ? void 0 : other.unstable_sxConfig);
|
|
muiTheme.unstable_sx = function sx(props) {
|
|
return (0, _styleFunctionSx.default)({
|
|
sx: props,
|
|
theme: this
|
|
});
|
|
};
|
|
return muiTheme;
|
|
}
|
|
var _default = exports.default = createTheme;
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createTheme/index.js
|
|
var require_createTheme2 = __commonJS({
|
|
"node_modules/@mui/system/createTheme/index.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
Object.defineProperty(exports, "default", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _createTheme.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "private_createBreakpoints", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _createBreakpoints.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "unstable_applyStyles", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _applyStyles.default;
|
|
}
|
|
});
|
|
var _createTheme = _interopRequireDefault(require_createTheme());
|
|
var _createBreakpoints = _interopRequireDefault(require_createBreakpoints());
|
|
var _applyStyles = _interopRequireDefault(require_applyStyles());
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/styleFunctionSx/extendSxProp.js
|
|
var require_extendSxProp = __commonJS({
|
|
"node_modules/@mui/system/styleFunctionSx/extendSxProp.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = extendSxProp;
|
|
var _extends2 = _interopRequireDefault(require_extends());
|
|
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require_objectWithoutPropertiesLoose());
|
|
var _deepmerge = (init_deepmerge(), __toCommonJS(deepmerge_exports));
|
|
var _defaultSxConfig = _interopRequireDefault(require_defaultSxConfig());
|
|
var _excluded = ["sx"];
|
|
var splitProps = (props) => {
|
|
var _props$theme$unstable, _props$theme;
|
|
const result = {
|
|
systemProps: {},
|
|
otherProps: {}
|
|
};
|
|
const config = (_props$theme$unstable = props == null || (_props$theme = props.theme) == null ? void 0 : _props$theme.unstable_sxConfig) != null ? _props$theme$unstable : _defaultSxConfig.default;
|
|
Object.keys(props).forEach((prop) => {
|
|
if (config[prop]) {
|
|
result.systemProps[prop] = props[prop];
|
|
} else {
|
|
result.otherProps[prop] = props[prop];
|
|
}
|
|
});
|
|
return result;
|
|
};
|
|
function extendSxProp(props) {
|
|
const {
|
|
sx: inSx
|
|
} = props, other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
|
|
const {
|
|
systemProps,
|
|
otherProps
|
|
} = splitProps(other);
|
|
let finalSx;
|
|
if (Array.isArray(inSx)) {
|
|
finalSx = [systemProps, ...inSx];
|
|
} else if (typeof inSx === "function") {
|
|
finalSx = (...args) => {
|
|
const result = inSx(...args);
|
|
if (!(0, _deepmerge.isPlainObject)(result)) {
|
|
return systemProps;
|
|
}
|
|
return (0, _extends2.default)({}, systemProps, result);
|
|
};
|
|
} else {
|
|
finalSx = (0, _extends2.default)({}, systemProps, inSx);
|
|
}
|
|
return (0, _extends2.default)({}, otherProps, {
|
|
sx: finalSx
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/styleFunctionSx/index.js
|
|
var require_styleFunctionSx2 = __commonJS({
|
|
"node_modules/@mui/system/styleFunctionSx/index.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
Object.defineProperty(exports, "default", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _styleFunctionSx.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "extendSxProp", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _extendSxProp.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "unstable_createStyleFunctionSx", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _styleFunctionSx.unstable_createStyleFunctionSx;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "unstable_defaultSxConfig", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _defaultSxConfig.default;
|
|
}
|
|
});
|
|
var _styleFunctionSx = _interopRequireWildcard(require_styleFunctionSx());
|
|
var _extendSxProp = _interopRequireDefault(require_extendSxProp());
|
|
var _defaultSxConfig = _interopRequireDefault(require_defaultSxConfig());
|
|
function _getRequireWildcardCache(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
|
|
return (_getRequireWildcardCache = function(e2) {
|
|
return e2 ? t : r;
|
|
})(e);
|
|
}
|
|
function _interopRequireWildcard(e, r) {
|
|
if (!r && 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;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/system/createStyled.js
|
|
var require_createStyled = __commonJS({
|
|
"node_modules/@mui/system/createStyled.js"(exports) {
|
|
"use strict";
|
|
var _interopRequireDefault = require_interopRequireDefault();
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = createStyled2;
|
|
exports.shouldForwardProp = shouldForwardProp;
|
|
exports.systemDefaultTheme = void 0;
|
|
var _extends2 = _interopRequireDefault(require_extends());
|
|
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require_objectWithoutPropertiesLoose());
|
|
var _styledEngine = _interopRequireWildcard((init_styled_engine(), __toCommonJS(styled_engine_exports)));
|
|
var _deepmerge = (init_deepmerge(), __toCommonJS(deepmerge_exports));
|
|
var _capitalize = _interopRequireDefault((init_capitalize(), __toCommonJS(capitalize_exports)));
|
|
var _getDisplayName = _interopRequireDefault((init_getDisplayName(), __toCommonJS(getDisplayName_exports)));
|
|
var _createTheme = _interopRequireDefault(require_createTheme2());
|
|
var _styleFunctionSx = _interopRequireDefault(require_styleFunctionSx2());
|
|
var _excluded = ["ownerState"];
|
|
var _excluded2 = ["variants"];
|
|
var _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"];
|
|
function _getRequireWildcardCache(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
|
|
return (_getRequireWildcardCache = function(e2) {
|
|
return e2 ? t : r;
|
|
})(e);
|
|
}
|
|
function _interopRequireWildcard(e, r) {
|
|
if (!r && 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;
|
|
}
|
|
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;
|
|
}
|
|
function shouldForwardProp(prop) {
|
|
return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as";
|
|
}
|
|
function shallowLayer(serialized, layerName) {
|
|
if (layerName && serialized && typeof serialized === "object" && serialized.styles && !serialized.styles.startsWith("@layer")) {
|
|
serialized.styles = `@layer ${layerName}{${String(serialized.styles)}}`;
|
|
}
|
|
return serialized;
|
|
}
|
|
var systemDefaultTheme = exports.systemDefaultTheme = (0, _createTheme.default)();
|
|
var 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, layerName) {
|
|
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), layerName));
|
|
}
|
|
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 ? void 0 : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) {
|
|
isMatch = false;
|
|
}
|
|
});
|
|
}
|
|
if (isMatch) {
|
|
if (!Array.isArray(result)) {
|
|
result = [result];
|
|
}
|
|
const variantStyle = typeof variant.style === "function" ? variant.style((0, _extends2.default)({
|
|
ownerState
|
|
}, props, ownerState)) : variant.style;
|
|
result.push(layerName ? shallowLayer((0, _styledEngine.internal_serializeStyles)(variantStyle), layerName) : variantStyle);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
return layerName ? shallowLayer((0, _styledEngine.internal_serializeStyles)(resolvedStylesArg), layerName) : resolvedStylesArg;
|
|
}
|
|
function createStyled2(input = {}) {
|
|
const {
|
|
themeId,
|
|
defaultTheme = systemDefaultTheme,
|
|
rootShouldForwardProp: rootShouldForwardProp2 = shouldForwardProp,
|
|
slotShouldForwardProp: slotShouldForwardProp2 = 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 = {}) => {
|
|
(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);
|
|
const layerName = componentName && componentName.startsWith("Mui") || !!componentSlot ? "components" : "custom";
|
|
const skipVariantsResolver = inputSkipVariantsResolver !== void 0 ? 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 (true) {
|
|
if (componentName) {
|
|
label = `${componentName}-${lowercaseFirstLetter(componentSlot || "Root")}`;
|
|
}
|
|
}
|
|
let shouldForwardPropOption = shouldForwardProp;
|
|
if (componentSlot === "Root" || componentSlot === "root") {
|
|
shouldForwardPropOption = rootShouldForwardProp2;
|
|
} else if (componentSlot) {
|
|
shouldForwardPropOption = slotShouldForwardProp2;
|
|
} else if (isStringTag(tag)) {
|
|
shouldForwardPropOption = void 0;
|
|
}
|
|
const defaultStyledResolver = (0, _styledEngine.default)(tag, (0, _extends2.default)({
|
|
shouldForwardProp: shouldForwardPropOption,
|
|
label
|
|
}, options));
|
|
const transformStyleArg = (stylesArg) => {
|
|
if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || (0, _deepmerge.isPlainObject)(stylesArg)) {
|
|
return (props) => {
|
|
const theme = resolveTheme({
|
|
theme: props.theme,
|
|
defaultTheme,
|
|
themeId
|
|
});
|
|
return processStyleArg(stylesArg, (0, _extends2.default)({}, props, {
|
|
theme
|
|
}), theme.modularCssLayers ? layerName : void 0);
|
|
};
|
|
}
|
|
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 = {};
|
|
Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => {
|
|
resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, (0, _extends2.default)({}, props, {
|
|
theme
|
|
}), theme.modularCssLayers ? "theme" : void 0);
|
|
});
|
|
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 ? void 0 : _theme$components.variants;
|
|
return processStyleArg({
|
|
variants: themeVariants
|
|
}, (0, _extends2.default)({}, props, {
|
|
theme
|
|
}), theme.modularCssLayers ? "theme" : void 0);
|
|
});
|
|
}
|
|
if (!skipSx) {
|
|
expressionsWithDefaultTheme.push(systemSx);
|
|
}
|
|
const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length;
|
|
if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) {
|
|
const placeholders = new Array(numOfCustomFnsApplied).fill("");
|
|
transformedStyleArg = [...styleArg, ...placeholders];
|
|
transformedStyleArg.raw = [...styleArg.raw, ...placeholders];
|
|
}
|
|
const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme);
|
|
if (true) {
|
|
let displayName;
|
|
if (componentName) {
|
|
displayName = `${componentName}${(0, _capitalize.default)(componentSlot || "")}`;
|
|
}
|
|
if (displayName === void 0) {
|
|
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;
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@mui/material/styles/styled.js
|
|
var import_createStyled = __toESM(require_createStyled());
|
|
|
|
// node_modules/@mui/material/styles/slotShouldForwardProp.js
|
|
function slotShouldForwardProp(prop) {
|
|
return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as";
|
|
}
|
|
var slotShouldForwardProp_default = slotShouldForwardProp;
|
|
|
|
// node_modules/@mui/material/styles/rootShouldForwardProp.js
|
|
var rootShouldForwardProp = (prop) => slotShouldForwardProp_default(prop) && prop !== "classes";
|
|
var rootShouldForwardProp_default = rootShouldForwardProp;
|
|
|
|
// node_modules/@mui/material/styles/styled.js
|
|
var styled = (0, import_createStyled.default)({
|
|
themeId: identifier_default,
|
|
defaultTheme: defaultTheme_default,
|
|
rootShouldForwardProp: rootShouldForwardProp_default
|
|
});
|
|
var styled_default = styled;
|
|
|
|
export {
|
|
slotShouldForwardProp_default,
|
|
rootShouldForwardProp_default,
|
|
styled_default
|
|
};
|
|
//# sourceMappingURL=chunk-JWRIH3ST.js.map
|