@tenancy.nz/datepicker 1.3.4

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/styleFunctionSx/defaultSxConfig.cjs

@@ -0,0 +1,300 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sizing = require('../sizing/sizing.cjs');
+var cssGrid = require('../cssGrid/cssGrid.cjs');
+var spacing = require('../spacing/spacing.cjs');
+var palette = require('../palette/palette.cjs');
+var borders = require('../borders/borders.cjs');
+
+const 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
+  font: {
+    themeKey: 'font'
+  },
+  fontFamily: {
+    themeKey: 'typography'
+  },
+  fontSize: {
+    themeKey: 'typography'
+  },
+  fontStyle: {
+    themeKey: 'typography'
+  },
+  fontWeight: {
+    themeKey: 'typography'
+  },
+  letterSpacing: {},
+  textTransform: {},
+  lineHeight: {},
+  textAlign: {},
+  typography: {
+    cssProperty: false,
+    themeKey: 'typography'
+  }
+};
+
+exports.default = defaultSxConfig;

package/dist/cjs/node_modules/.pnpm/@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/styleFunctionSx/styleFunctionSx.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var defaultSxConfig = require('./defaultSxConfig.cjs');
+var breakpoints = require('../breakpoints/breakpoints.cjs');
+var merge = require('../merge/merge.cjs');
+var cssContainerQueries = require('../cssContainerQueries/cssContainerQueries.cjs');
+var style = require('../style/style.cjs');
+var capitalize = require('../../../../../../@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/capitalize/capitalize.cjs');
+
+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;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+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: style$1
+    } = options;
+    if (val == null) {
+      return null;
+    }
+
+    // TODO v6: remove, see https://github.com/mui/material-ui/pull/38123
+    if (themeKey === 'typography' && val === 'inherit') {
+      return {
+        [prop]: val
+      };
+    }
+    const themeMapping = style.getPath(theme, themeKey) || {};
+    if (style$1) {
+      return style$1(props);
+    }
+    const styleFromPropValue = propValueFinal => {
+      let value = style.getStyleValue(themeMapping, transform, propValueFinal);
+      if (propValueFinal === value && typeof propValueFinal === 'string') {
+        // Haven't found value
+        value = style.getStyleValue(themeMapping, transform, `${prop}${propValueFinal === 'default' ? '' : capitalize.default(propValueFinal)}`, propValueFinal);
+      }
+      if (cssProperty === false) {
+        return value;
+      }
+      return {
+        [cssProperty]: value
+      };
+    };
+    return breakpoints.handleBreakpoints(props, val, styleFromPropValue);
+  }
+  function styleFunctionSx(props) {
+    const {
+      sx,
+      theme = {},
+      nested
+    } = props || {};
+    if (!sx) {
+      return null; // Emotion & styled-components will neglect null
+    }
+    const config = theme.unstable_sxConfig ?? defaultSxConfig.default;
+
+    /*
+     * Receive `sxInput` as object or callback
+     * and then recursively check keys & values to create media query object styles.
+     * (the result will be used in `styled`)
+     */
+    function traverse(sxInput) {
+      let sxObject = sxInput;
+      if (typeof sxInput === 'function') {
+        sxObject = sxInput(theme);
+      } else if (typeof sxInput !== 'object') {
+        // value
+        return sxInput;
+      }
+      if (!sxObject) {
+        return null;
+      }
+      const emptyBreakpoints = 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 !== undefined) {
+          if (typeof value === 'object') {
+            if (config[styleKey]) {
+              css = merge.default(css, getThemeValue(styleKey, value, theme, config));
+            } else {
+              const breakpointsValues = breakpoints.handleBreakpoints({
+                theme
+              }, value, x => ({
+                [styleKey]: x
+              }));
+              if (objectsHaveSameKeys(breakpointsValues, value)) {
+                css[styleKey] = styleFunctionSx({
+                  sx: value,
+                  theme,
+                  nested: true
+                });
+              } else {
+                css = merge.default(css, breakpointsValues);
+              }
+            }
+          } else {
+            css = merge.default(css, getThemeValue(styleKey, value, theme, config));
+          }
+        }
+      });
+      if (!nested && theme.modularCssLayers) {
+        return {
+          '@layer sx': cssContainerQueries.sortContainerQueries(theme, breakpoints.removeUnusedBreakpoints(breakpointsKeys, css))
+        };
+      }
+      return cssContainerQueries.sortContainerQueries(theme, breakpoints.removeUnusedBreakpoints(breakpointsKeys, css));
+    }
+    return Array.isArray(sx) ? sx.map(traverse) : traverse(sx);
+  }
+  return styleFunctionSx;
+}
+const styleFunctionSx = unstable_createStyleFunctionSx();
+styleFunctionSx.filterProps = ['sx'];
+
+exports.default = styleFunctionSx;
+exports.unstable_createStyleFunctionSx = unstable_createStyleFunctionSx;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/capitalize/capitalize.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var formatMuiErrorMessage = require('../formatMuiErrorMessage/formatMuiErrorMessage.cjs');
+
+// It should to be noted that this function isn't equivalent to `text-transform: capitalize`.
+//
+// A strict capitalization should uppercase the first letter of each word in the sentence.
+// We only handle the first word.
+function capitalize(string) {
+  if (typeof string !== 'string') {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: `capitalize(string)` expects a string argument.' : formatMuiErrorMessage.default(7));
+  }
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+exports.default = capitalize;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/deepmerge/deepmerge.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var require$$0 = require('react-is');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+// https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
+function isPlainObject(item) {
+  if (typeof item !== 'object' || item === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(item);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in item) && !(Symbol.iterator in item);
+}
+function deepClone(source) {
+  if (/*#__PURE__*/React__namespace.isValidElement(source) || require$$0.isValidElementType(source) || !isPlainObject(source)) {
+    return source;
+  }
+  const output = {};
+  Object.keys(source).forEach(key => {
+    output[key] = deepClone(source[key]);
+  });
+  return output;
+}
+
+/**
+ * Merge objects deeply.
+ * It will shallow copy React elements.
+ *
+ * If `options.clone` is set to `false` the source object will be merged directly into the target object.
+ *
+ * @example
+ * ```ts
+ * deepmerge({ a: { b: 1 }, d: 2 }, { a: { c: 2 }, d: 4 });
+ * // => { a: { b: 1, c: 2 }, d: 4 }
+ * ````
+ *
+ * @param target The target object.
+ * @param source The source object.
+ * @param options The merge options.
+ * @param options.clone Set to `false` to merge the source object directly into the target object.
+ * @returns The merged object.
+ */
+function deepmerge(target, source, options = {
+  clone: true
+}) {
+  const output = options.clone ? {
+    ...target
+  } : target;
+  if (isPlainObject(target) && isPlainObject(source)) {
+    Object.keys(source).forEach(key => {
+      if (/*#__PURE__*/React__namespace.isValidElement(source[key]) || require$$0.isValidElementType(source[key])) {
+        output[key] = source[key];
+      } else if (isPlainObject(source[key]) &&
+      // Avoid prototype pollution
+      Object.prototype.hasOwnProperty.call(target, key) && isPlainObject(target[key])) {
+        // Since `output` is a clone of `target` and we have narrowed `target` in this block we can cast to the same type.
+        output[key] = deepmerge(target[key], source[key], options);
+      } else if (options.clone) {
+        output[key] = isPlainObject(source[key]) ? deepClone(source[key]) : source[key];
+      } else {
+        output[key] = source[key];
+      }
+    });
+  }
+  return output;
+}
+
+exports.default = deepmerge;
+exports.isPlainObject = isPlainObject;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.1_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/formatMuiErrorMessage/formatMuiErrorMessage.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * WARNING: Don't import this directly. It's imported by the code generated by
+ * `@mui/interal-babel-plugin-minify-errors`. Make sure to always use string literals in `Error`
+ * constructors to ensure the plugin works as expected. Supported patterns include:
+ *   throw new Error('My message');
+ *   throw new Error(`My message: ${foo}`);
+ *   throw new Error(`My message: ${foo}` + 'another string');
+ *   ...
+ * @param {number} code
+ */
+function formatMuiErrorMessage(code, ...args) {
+  const url = new URL(`https://mui.com/production-error/?code=${code}`);
+  args.forEach(arg => url.searchParams.append('args[]', arg));
+  return `Minified MUI error #${code}; visit ${url} for the full message.`;
+}
+
+exports.default = formatMuiErrorMessage;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/ClassNameGenerator/ClassNameGenerator.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const defaultGenerator = componentName => componentName;
+const createClassNameGenerator = () => {
+  let generate = defaultGenerator;
+  return {
+    configure(generator) {
+      generate = generator;
+    },
+    generate(componentName) {
+      return generate(componentName);
+    },
+    reset() {
+      generate = defaultGenerator;
+    }
+  };
+};
+const ClassNameGenerator = createClassNameGenerator();
+
+exports.default = ClassNameGenerator;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/appendOwnerState/appendOwnerState.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isHostComponent = require('../isHostComponent/isHostComponent.cjs');
+
+/**
+ * Type of the ownerState based on the type of an element it applies to.
+ * This resolves to the provided OwnerState for React components and `undefined` for host components.
+ * Falls back to `OwnerState | undefined` when the exact type can't be determined in development time.
+ */
+
+/**
+ * Appends the ownerState object to the props, merging with the existing one if necessary.
+ *
+ * @param elementType Type of the element that owns the `existingProps`. If the element is a DOM node or undefined, `ownerState` is not applied.
+ * @param otherProps Props of the element.
+ * @param ownerState
+ */
+function appendOwnerState(elementType, otherProps, ownerState) {
+  if (elementType === undefined || isHostComponent.default(elementType)) {
+    return otherProps;
+  }
+  return {
+    ...otherProps,
+    ownerState: {
+      ...otherProps.ownerState,
+      ...ownerState
+    }
+  };
+}
+
+exports.default = appendOwnerState;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/capitalize/capitalize.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var formatMuiErrorMessage = require('../formatMuiErrorMessage/formatMuiErrorMessage.cjs');
+
+// It should to be noted that this function isn't equivalent to `text-transform: capitalize`.
+//
+// A strict capitalization should uppercase the first letter of each word in the sentence.
+// We only handle the first word.
+function capitalize(string) {
+  if (typeof string !== 'string') {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'MUI: `capitalize(string)` expects a string argument.' : formatMuiErrorMessage.default(7));
+  }
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+exports.default = capitalize;

package/dist/cjs/node_modules/.pnpm/@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint no-restricted-syntax: 0, prefer-template: 0, guard-for-in: 0
+   ---
+   These rules are preventing the performance optimizations below.
+ */
+
+/**
+ * Compose classes from multiple sources.
+ *
+ * @example
+ * ```tsx
+ * const slots = {
+ *  root: ['root', 'primary'],
+ *  label: ['label'],
+ * };
+ *
+ * const getUtilityClass = (slot) => `MuiButton-${slot}`;
+ *
+ * const classes = {
+ *   root: 'my-root-class',
+ * };
+ *
+ * const output = composeClasses(slots, getUtilityClass, classes);
+ * // {
+ * //   root: 'MuiButton-root MuiButton-primary my-root-class',
+ * //   label: 'MuiButton-label',
+ * // }
+ * ```
+ *
+ * @param slots a list of classes for each possible slot
+ * @param getUtilityClass a function to resolve the class based on the slot name
+ * @param classes the input classes from props
+ * @returns the resolved classes for all slots
+ */
+function composeClasses(slots, getUtilityClass, classes = undefined) {
+  const output = {};
+  for (const slotName in slots) {
+    const slot = slots[slotName];
+    let buffer = '';
+    let start = true;
+    for (let i = 0; i < slot.length; i += 1) {
+      const value = slot[i];
+      if (value) {
+        buffer += (start === true ? '' : ' ') + getUtilityClass(value);
+        start = false;
+        if (classes && classes[value]) {
+          buffer += ' ' + classes[value];
+        }
+      }
+    }
+    output[slotName] = buffer;
+  }
+  return output;
+}
+
+exports.default = composeClasses;