@dbmx/toasts 0.0.122 → 0.0.123

package/cjs/node_modules/@mui/system/esm/compose.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var merge = require('./merge.cjs');
+
+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 = 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/cjs/node_modules/@mui/system/esm/createTheme/applyStyles.cjs

@@ -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/cjs/node_modules/@mui/system/esm/createTheme/createBreakpoints.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+var objectWithoutPropertiesLoose = require('../../../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var _extends = require('../../../../@babel/runtime/helpers/esm/extends.cjs');
+
+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/cjs/node_modules/@mui/system/esm/createTheme/createSpacing.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var spacing = require('../spacing.cjs');
+
+// 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 (!(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/cjs/node_modules/@mui/system/esm/createTheme/createTheme.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var _extends = require('../../../../@babel/runtime/helpers/esm/extends.cjs');
+var objectWithoutPropertiesLoose = require('../../../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var createBreakpoints = require('./createBreakpoints.cjs');
+var shape = require('./shape.cjs');
+var createSpacing = require('./createSpacing.cjs');
+var styleFunctionSx = require('../styleFunctionSx/styleFunctionSx.cjs');
+var defaultSxConfig = require('../styleFunctionSx/defaultSxConfig.cjs');
+var applyStyles = require('./applyStyles.cjs');
+var deepmerge = require('../../../utils/deepmerge/deepmerge.cjs');
+
+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 ? void 0 : other.unstable_sxConfig);
+  muiTheme.unstable_sx = function sx(props) {
+    return styleFunctionSx.default({
+      sx: props,
+      theme: this
+    });
+  };
+  return muiTheme;
+}
+
+module.exports = createTheme;

package/cjs/node_modules/@mui/system/esm/createTheme/shape.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+const shape = {
+  borderRadius: 4
+};
+var shape$1 = shape;
+
+module.exports = shape$1;

package/cjs/node_modules/@mui/system/esm/cssGrid.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+var style = require('./style.cjs');
+var compose = require('./compose.cjs');
+var spacing = require('./spacing.cjs');
+var breakpoints = require('./breakpoints.cjs');
+var responsivePropType = require('./responsivePropType.cjs');
+
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const gap = props => {
+  if (props.gap !== undefined && props.gap !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'spacing', 8, 'gap');
+    const styleFromPropValue = propValue => ({
+      gap: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.gap, styleFromPropValue);
+  }
+  return null;
+};
+gap.propTypes = {
+  gap: responsivePropType
+} ;
+gap.filterProps = ['gap'];
+
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const columnGap = props => {
+  if (props.columnGap !== undefined && props.columnGap !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'spacing', 8, 'columnGap');
+    const styleFromPropValue = propValue => ({
+      columnGap: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.columnGap, styleFromPropValue);
+  }
+  return null;
+};
+columnGap.propTypes = {
+  columnGap: responsivePropType
+} ;
+columnGap.filterProps = ['columnGap'];
+
+// false positive
+// eslint-disable-next-line react/function-component-definition
+const rowGap = props => {
+  if (props.rowGap !== undefined && props.rowGap !== null) {
+    const transformer = spacing.createUnaryUnit(props.theme, 'spacing', 8, 'rowGap');
+    const styleFromPropValue = propValue => ({
+      rowGap: spacing.getValue(transformer, propValue)
+    });
+    return breakpoints.handleBreakpoints(props, props.rowGap, styleFromPropValue);
+  }
+  return null;
+};
+rowGap.propTypes = {
+  rowGap: responsivePropType
+} ;
+rowGap.filterProps = ['rowGap'];
+const gridColumn = style.default({
+  prop: 'gridColumn'
+});
+const gridRow = style.default({
+  prop: 'gridRow'
+});
+const gridAutoFlow = style.default({
+  prop: 'gridAutoFlow'
+});
+const gridAutoColumns = style.default({
+  prop: 'gridAutoColumns'
+});
+const gridAutoRows = style.default({
+  prop: 'gridAutoRows'
+});
+const gridTemplateColumns = style.default({
+  prop: 'gridTemplateColumns'
+});
+const gridTemplateRows = style.default({
+  prop: 'gridTemplateRows'
+});
+const gridTemplateAreas = style.default({
+  prop: 'gridTemplateAreas'
+});
+const gridArea = style.default({
+  prop: 'gridArea'
+});
+compose(gap, columnGap, rowGap, gridColumn, gridRow, gridAutoFlow, gridAutoColumns, gridAutoRows, gridTemplateColumns, gridTemplateRows, gridTemplateAreas, gridArea);
+
+exports.columnGap = columnGap;
+exports.gap = gap;
+exports.gridArea = gridArea;
+exports.gridAutoColumns = gridAutoColumns;
+exports.gridAutoFlow = gridAutoFlow;
+exports.gridAutoRows = gridAutoRows;
+exports.gridColumn = gridColumn;
+exports.gridRow = gridRow;
+exports.gridTemplateAreas = gridTemplateAreas;
+exports.gridTemplateColumns = gridTemplateColumns;
+exports.gridTemplateRows = gridTemplateRows;
+exports.rowGap = rowGap;

package/cjs/node_modules/@mui/system/esm/memoize.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function memoize(fn) {
+  const cache = {};
+  return arg => {
+    if (cache[arg] === undefined) {
+      cache[arg] = fn(arg);
+    }
+    return cache[arg];
+  };
+}
+
+module.exports = memoize;

package/cjs/node_modules/@mui/system/esm/merge.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var deepmerge = require('../../utils/deepmerge/deepmerge.cjs');
+
+function merge(acc, item) {
+  if (!item) {
+    return acc;
+  }
+  return deepmerge.default(acc, item, {
+    clone: false // No need to clone deep, it's way faster.
+  });
+}
+
+module.exports = merge;

package/cjs/node_modules/@mui/system/esm/palette.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var style = require('./style.cjs');
+var compose = require('./compose.cjs');
+
+function paletteTransform(value, userValue) {
+  if (userValue === 'grey') {
+    return userValue;
+  }
+  return value;
+}
+const color = style.default({
+  prop: 'color',
+  themeKey: 'palette',
+  transform: paletteTransform
+});
+const bgcolor = style.default({
+  prop: 'bgcolor',
+  cssProperty: 'backgroundColor',
+  themeKey: 'palette',
+  transform: paletteTransform
+});
+const backgroundColor = style.default({
+  prop: 'backgroundColor',
+  themeKey: 'palette',
+  transform: paletteTransform
+});
+compose(color, bgcolor, backgroundColor);
+
+exports.backgroundColor = backgroundColor;
+exports.bgcolor = bgcolor;
+exports.color = color;
+exports.paletteTransform = paletteTransform;

package/cjs/node_modules/@mui/system/esm/responsivePropType.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var PropTypes = require('prop-types');
+
+const responsivePropType = PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.object, PropTypes.array]) ;
+var responsivePropType$1 = responsivePropType;
+
+module.exports = responsivePropType$1;

package/cjs/node_modules/@mui/system/esm/sizing.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var style = require('./style.cjs');
+var compose = require('./compose.cjs');
+var breakpoints = require('./breakpoints.cjs');
+
+function sizingTransform(value) {
+  return value <= 1 && value !== 0 ? `${value * 100}%` : value;
+}
+const width = style.default({
+  prop: 'width',
+  transform: sizingTransform
+});
+const maxWidth = props => {
+  if (props.maxWidth !== undefined && 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 breakpoints.handleBreakpoints(props, props.maxWidth, styleFromPropValue);
+  }
+  return null;
+};
+maxWidth.filterProps = ['maxWidth'];
+const minWidth = style.default({
+  prop: 'minWidth',
+  transform: sizingTransform
+});
+const height = style.default({
+  prop: 'height',
+  transform: sizingTransform
+});
+const maxHeight = style.default({
+  prop: 'maxHeight',
+  transform: sizingTransform
+});
+const minHeight = style.default({
+  prop: 'minHeight',
+  transform: sizingTransform
+});
+style.default({
+  prop: 'size',
+  cssProperty: 'width',
+  transform: sizingTransform
+});
+style.default({
+  prop: 'size',
+  cssProperty: 'height',
+  transform: sizingTransform
+});
+const boxSizing = style.default({
+  prop: 'boxSizing'
+});
+compose(width, maxWidth, minWidth, height, maxHeight, minHeight, boxSizing);
+
+exports.boxSizing = boxSizing;
+exports.height = height;
+exports.maxHeight = maxHeight;
+exports.maxWidth = maxWidth;
+exports.minHeight = minHeight;
+exports.minWidth = minWidth;
+exports.sizingTransform = sizingTransform;
+exports.width = width;

package/cjs/node_modules/@mui/system/esm/spacing.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+var responsivePropType = require('./responsivePropType.cjs');
+var breakpoints = require('./breakpoints.cjs');
+var style$1 = require('./style.cjs');
+var merge = require('./merge.cjs');
+var memoize = require('./memoize.cjs');
+
+const properties = {
+  m: 'margin',
+  p: 'padding'
+};
+const directions = {
+  t: 'Top',
+  r: 'Right',
+  b: 'Bottom',
+  l: 'Left',
+  x: ['Left', 'Right'],
+  y: ['Top', 'Bottom']
+};
+const aliases = {
+  marginX: 'mx',
+  marginY: 'my',
+  paddingX: 'px',
+  paddingY: 'py'
+};
+
+// memoize() impact:
+// From 300,000 ops/sec
+// To 350,000 ops/sec
+const getCssProperties = memoize(prop => {
+  // It's not a shorthand notation.
+  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];
+});
+const marginKeys = ['m', 'mt', 'mr', 'mb', 'ml', 'mx', 'my', 'margin', 'marginTop', 'marginRight', 'marginBottom', 'marginLeft', 'marginX', 'marginY', 'marginInline', 'marginInlineStart', 'marginInlineEnd', 'marginBlock', 'marginBlockStart', 'marginBlockEnd'];
+const paddingKeys = ['p', 'pt', 'pr', 'pb', 'pl', 'px', 'py', 'padding', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft', 'paddingX', 'paddingY', 'paddingInline', 'paddingInlineStart', 'paddingInlineEnd', 'paddingBlock', 'paddingBlockStart', 'paddingBlockEnd'];
+const spacingKeys = [...marginKeys, ...paddingKeys];
+function createUnaryUnit(theme, themeKey, defaultValue, propName) {
+  var _getPath;
+  const themeSpacing = (_getPath = style$1.getPath(theme, themeKey, false)) != null ? _getPath : defaultValue;
+  if (typeof themeSpacing === 'number') {
+    return abs => {
+      if (typeof abs === 'string') {
+        return abs;
+      }
+      {
+        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 (!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;
+  }
+  {
+    console.error([`MUI: The \`theme.${themeKey}\` value (${themeSpacing}) is invalid.`, 'It should be a number, an array or a function.'].join('\n'));
+  }
+  return () => undefined;
+}
+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) {
+  // Using a hash computation over an array iteration could be faster, but with only 28 items,
+  // it's doesn't worth the bundle size.
+  if (keys.indexOf(prop) === -1) {
+    return null;
+  }
+  const cssProperties = getCssProperties(prop);
+  const styleFromPropValue = getStyleFromPropValue(cssProperties, transformer);
+  const propValue = props[prop];
+  return 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, {});
+}
+function margin(props) {
+  return style(props, marginKeys);
+}
+margin.propTypes = marginKeys.reduce((obj, key) => {
+  obj[key] = responsivePropType;
+  return obj;
+}, {}) ;
+margin.filterProps = marginKeys;
+function padding(props) {
+  return style(props, paddingKeys);
+}
+padding.propTypes = paddingKeys.reduce((obj, key) => {
+  obj[key] = responsivePropType;
+  return obj;
+}, {}) ;
+padding.filterProps = paddingKeys;
+spacingKeys.reduce((obj, key) => {
+  obj[key] = responsivePropType;
+  return obj;
+}, {}) ;
+
+exports.createUnarySpacing = createUnarySpacing;
+exports.createUnaryUnit = createUnaryUnit;
+exports.getStyleFromPropValue = getStyleFromPropValue;
+exports.getValue = getValue;
+exports.margin = margin;
+exports.marginKeys = marginKeys;
+exports.padding = padding;
+exports.paddingKeys = paddingKeys;