@tenancy.nz/datepicker 1.3.4

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/locales/enUS.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+var getPickersLocalization = require('./utils/getPickersLocalization.cjs');
+
+// This object is not Partial<PickersLocaleText> because it is the default values
+
+const enUSPickers = {
+  // Calendar navigation
+  previousMonth: 'Previous month',
+  nextMonth: 'Next month',
+  // View navigation
+  openPreviousView: 'Open previous view',
+  openNextView: 'Open next view',
+  calendarViewSwitchingButtonAriaLabel: view => view === 'year' ? 'year view is open, switch to calendar view' : 'calendar view is open, switch to year view',
+  // DateRange labels
+  start: 'Start',
+  end: 'End',
+  startDate: 'Start date',
+  startTime: 'Start time',
+  endDate: 'End date',
+  endTime: 'End time',
+  // Action bar
+  cancelButtonLabel: 'Cancel',
+  clearButtonLabel: 'Clear',
+  okButtonLabel: 'OK',
+  todayButtonLabel: 'Today',
+  nextStepButtonLabel: 'Next',
+  // Toolbar titles
+  datePickerToolbarTitle: 'Select date',
+  dateTimePickerToolbarTitle: 'Select date & time',
+  timePickerToolbarTitle: 'Select time',
+  dateRangePickerToolbarTitle: 'Select date range',
+  timeRangePickerToolbarTitle: 'Select time range',
+  // Clock labels
+  clockLabelText: (view, formattedTime) => `Select ${view}. ${!formattedTime ? 'No time selected' : `Selected time is ${formattedTime}`}`,
+  hoursClockNumberText: hours => `${hours} hours`,
+  minutesClockNumberText: minutes => `${minutes} minutes`,
+  secondsClockNumberText: seconds => `${seconds} seconds`,
+  // Digital clock labels
+  selectViewText: view => `Select ${view}`,
+  // Calendar labels
+  calendarWeekNumberHeaderLabel: 'Week number',
+  calendarWeekNumberHeaderText: '#',
+  calendarWeekNumberAriaLabelText: weekNumber => `Week ${weekNumber}`,
+  calendarWeekNumberText: weekNumber => `${weekNumber}`,
+  // Open Picker labels
+  openDatePickerDialogue: formattedDate => formattedDate ? `Choose date, selected date is ${formattedDate}` : 'Choose date',
+  openTimePickerDialogue: formattedTime => formattedTime ? `Choose time, selected time is ${formattedTime}` : 'Choose time',
+  openRangePickerDialogue: formattedRange => formattedRange ? `Choose range, selected range is ${formattedRange}` : 'Choose range',
+  fieldClearLabel: 'Clear',
+  // Table labels
+  timeTableLabel: 'pick time',
+  dateTableLabel: 'pick date',
+  // Field section placeholders
+  fieldYearPlaceholder: params => 'Y'.repeat(params.digitAmount),
+  fieldMonthPlaceholder: params => params.contentType === 'letter' ? 'MMMM' : 'MM',
+  fieldDayPlaceholder: () => 'DD',
+  fieldWeekDayPlaceholder: params => params.contentType === 'letter' ? 'EEEE' : 'EE',
+  fieldHoursPlaceholder: () => 'hh',
+  fieldMinutesPlaceholder: () => 'mm',
+  fieldSecondsPlaceholder: () => 'ss',
+  fieldMeridiemPlaceholder: () => 'aa',
+  // View names
+  year: 'Year',
+  month: 'Month',
+  day: 'Day',
+  weekDay: 'Week day',
+  hours: 'Hours',
+  minutes: 'Minutes',
+  seconds: 'Seconds',
+  meridiem: 'Meridiem',
+  // Common
+  empty: 'Empty'
+};
+const DEFAULT_LOCALE = enUSPickers;
+getPickersLocalization.getPickersLocalization(enUSPickers);
+
+exports.DEFAULT_LOCALE = DEFAULT_LOCALE;

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/locales/utils/getPickersLocalization.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+
+const getPickersLocalization = pickersTranslations => {
+  return {
+    components: {
+      MuiLocalizationProvider: {
+        defaultProps: {
+          localeText: _extends.default({}, pickersTranslations)
+        }
+      }
+    }
+  };
+};
+
+exports.getPickersLocalization = getPickersLocalization;

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/managers/useDateManager.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+var _extends = require('../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var dateUtils = require('../internals/utils/date-utils.cjs');
+var valueManagers = require('../internals/utils/valueManagers.cjs');
+var useUtils = require('../internals/hooks/useUtils.cjs');
+var usePickerAdapter = require('../hooks/usePickerAdapter.cjs');
+var validateDate = require('../validation/validateDate.cjs');
+var usePickerTranslations = require('../hooks/usePickerTranslations.cjs');
+
+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);
+
+function useDateManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React__namespace.useMemo(() => ({
+    valueType: 'date',
+    validator: validateDate.validateDate,
+    internal_valueManager: valueManagers.singleItemValueManager,
+    internal_fieldValueManager: valueManagers.singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_useApplyDefaultValuesToFieldInternalProps: useApplyDefaultValuesToDateFieldInternalProps,
+    internal_useOpenPickerButtonAriaLabel: useOpenPickerButtonAriaLabel
+  }), [enableAccessibleFieldDOMStructure]);
+}
+function useOpenPickerButtonAriaLabel(value) {
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const translations = usePickerTranslations.usePickerTranslations();
+  return React__namespace.useMemo(() => {
+    const formattedValue = adapter.isValid(value) ? adapter.format(value, 'fullDate') : null;
+    return translations.openDatePickerDialogue(formattedValue);
+  }, [value, translations, adapter]);
+}
+function useApplyDefaultValuesToDateFieldInternalProps(internalProps) {
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const validationProps = useApplyDefaultValuesToDateValidationProps(internalProps);
+  return React__namespace.useMemo(() => _extends.default({}, internalProps, validationProps, {
+    format: internalProps.format ?? adapter.formats.keyboardDate
+  }), [internalProps, validationProps, adapter]);
+}
+function useApplyDefaultValuesToDateValidationProps(props) {
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const defaultDates = useUtils.useDefaultDates();
+  return React__namespace.useMemo(() => ({
+    disablePast: props.disablePast ?? false,
+    disableFuture: props.disableFuture ?? false,
+    minDate: dateUtils.applyDefaultDate(adapter, props.minDate, defaultDates.minDate),
+    maxDate: dateUtils.applyDefaultDate(adapter, props.maxDate, defaultDates.maxDate)
+  }), [props.minDate, props.maxDate, props.disableFuture, props.disablePast, adapter, defaultDates]);
+}
+
+exports.useApplyDefaultValuesToDateValidationProps = useApplyDefaultValuesToDateValidationProps;
+exports.useDateManager = useDateManager;

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/validation/extractValidationProps.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const DATE_VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minDate', 'maxDate', 'shouldDisableDate', 'shouldDisableMonth', 'shouldDisableYear'];
+const TIME_VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minTime', 'maxTime', 'shouldDisableTime', 'minutesStep', 'ampm', 'disableIgnoringDatePartForTimeValidation'];
+const DATE_TIME_VALIDATION_PROP_NAMES = ['minDateTime', 'maxDateTime'];
+const VALIDATION_PROP_NAMES = [...DATE_VALIDATION_PROP_NAMES, ...TIME_VALIDATION_PROP_NAMES, ...DATE_TIME_VALIDATION_PROP_NAMES];
+/**
+ * Extract the validation props for the props received by a component.
+ * Limit the risk of forgetting some of them and reduce the bundle size.
+ */
+const extractValidationProps = props => VALIDATION_PROP_NAMES.reduce((extractedProps, propName) => {
+  if (props.hasOwnProperty(propName)) {
+    extractedProps[propName] = props[propName];
+  }
+  return extractedProps;
+}, {});
+
+exports.DATE_TIME_VALIDATION_PROP_NAMES = DATE_TIME_VALIDATION_PROP_NAMES;
+exports.DATE_VALIDATION_PROP_NAMES = DATE_VALIDATION_PROP_NAMES;
+exports.TIME_VALIDATION_PROP_NAMES = TIME_VALIDATION_PROP_NAMES;
+exports.extractValidationProps = extractValidationProps;

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/validation/useValidation.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var React = require('react');
+var usePickerAdapter = require('../hooks/usePickerAdapter.cjs');
+var useEventCallback = require('../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.cjs');
+
+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);
+
+/**
+ * Utility hook to check if a given value is valid based on the provided validation props.
+ * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+ * @template TError The validation error type. It will be either `string` or a `null`. It can be in `[start, end]` format in case of range value.
+ * @param {UseValidationOptions<TValue, TError, TValidationProps>} options The options to configure the hook.
+ * @param {TValue} options.value The value to validate.
+ * @param {PickersTimezone} options.timezone The timezone to use for the validation.
+ * @param {Validator<TValue, TError, TValidationProps>} options.validator The validator function to use.
+ * @param {TValidationProps} options.props The validation props, they differ depending on the component.
+ * @param {(error: TError, value: TValue) => void} options.onError Callback fired when the error associated with the current value changes.
+ */
+function useValidation(options) {
+  const {
+    props,
+    validator,
+    value,
+    timezone,
+    onError
+  } = options;
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const previousValidationErrorRef = React__namespace.useRef(validator.valueManager.defaultErrorState);
+  const validationError = validator({
+    adapter,
+    value,
+    timezone,
+    props
+  });
+  const hasValidationError = validator.valueManager.hasError(validationError);
+  React__namespace.useEffect(() => {
+    if (onError && !validator.valueManager.isSameError(validationError, previousValidationErrorRef.current)) {
+      onError(validationError, value);
+    }
+    previousValidationErrorRef.current = validationError;
+  }, [validator, onError, validationError, value]);
+  const getValidationErrorForNewValue = useEventCallback.default(newValue => {
+    return validator({
+      adapter,
+      value: newValue,
+      timezone,
+      props
+    });
+  });
+  return {
+    validationError,
+    hasValidationError,
+    getValidationErrorForNewValue
+  };
+}
+
+exports.useValidation = useValidation;

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/validation/validateDate.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var valueManagers = require('../internals/utils/valueManagers.cjs');
+
+/**
+ * Validation props used by the Date Picker, Date Field and Date Calendar components.
+ */
+
+/**
+ * Validation props as received by the validateDate method.
+ */
+
+/**
+ * Name of the props that should be defaulted before being passed to the validateDate method.
+ */
+
+const validateDate = ({
+  props,
+  value,
+  timezone,
+  adapter
+}) => {
+  if (value === null) {
+    return null;
+  }
+  const {
+    shouldDisableDate,
+    shouldDisableMonth,
+    shouldDisableYear,
+    disablePast,
+    disableFuture,
+    minDate,
+    maxDate
+  } = props;
+  const now = adapter.date(undefined, timezone);
+  switch (true) {
+    case !adapter.isValid(value):
+      return 'invalidDate';
+    case Boolean(shouldDisableDate && shouldDisableDate(value)):
+      return 'shouldDisableDate';
+    case Boolean(shouldDisableMonth && shouldDisableMonth(value)):
+      return 'shouldDisableMonth';
+    case Boolean(shouldDisableYear && shouldDisableYear(value)):
+      return 'shouldDisableYear';
+    case Boolean(disableFuture && adapter.isAfterDay(value, now)):
+      return 'disableFuture';
+    case Boolean(disablePast && adapter.isBeforeDay(value, now)):
+      return 'disablePast';
+    case Boolean(minDate && adapter.isBeforeDay(value, minDate)):
+      return 'minDate';
+    case Boolean(maxDate && adapter.isAfterDay(value, maxDate)):
+      return 'maxDate';
+    default:
+      return null;
+  }
+};
+validateDate.valueManager = valueManagers.singleItemValueManager;
+
+exports.validateDate = validateDate;

package/dist/cjs/node_modules/.pnpm/@mui_x-internals@8.26.0_@types_react@19.1.9_react@18.3.1/node_modules/@mui/x-internals/esm/warning/warning.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+const warnedOnceCache = new Set();
+
+/**
+ * Logs a message to the console on development mode. The warning will only be logged once.
+ *
+ * The message is the log's cache key. Two identical messages will only be logged once.
+ *
+ * This function is a no-op in production.
+ *
+ * @param message the message to log
+ * @param gravity the gravity of the warning. Defaults to `'warning'`.
+ * @returns
+ */
+function warnOnce(message, gravity = 'warning') {
+  if (process.env.NODE_ENV === 'production') {
+    return;
+  }
+  const cleanMessage = Array.isArray(message) ? message.join('\n') : message;
+  if (!warnedOnceCache.has(cleanMessage)) {
+    warnedOnceCache.add(cleanMessage);
+    if (gravity === 'error') {
+      console.error(cleanMessage);
+    } else {
+      console.warn(cleanMessage);
+    }
+  }
+}
+
+exports.warnOnce = warnOnce;

package/dist/cjs/node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+exports.clsx = clsx;
+exports.default = clsx;

package/dist/cjs/node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+var objectAssign;
+var hasRequiredObjectAssign;
+
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+	return objectAssign;
+}
+
+exports.__require = requireObjectAssign;

package/dist/cjs/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret.cjs');
+var has = require('./lib/has.cjs');
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var checkPropTypes_1;
+var hasRequiredCheckPropTypes;
+
+function requireCheckPropTypes () {
+	if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+	hasRequiredCheckPropTypes = 1;
+
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactPropTypesSecret$1 = /*@__PURE__*/ ReactPropTypesSecret.__require();
+	  var loggedTypeFailures = {};
+	  var has$1 = /*@__PURE__*/ has.__require();
+
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) { /**/ }
+	  };
+	}
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?Function} getStack Returns the component stack.
+	 * @private
+	 */
+	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    for (var typeSpecName in typeSpecs) {
+	      if (has$1(typeSpecs, typeSpecName)) {
+	        var error;
+	        // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            var err = Error(
+	              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+	              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
+	              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
+	            );
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
+	        } catch (ex) {
+	          error = ex;
+	        }
+	        if (error && !(error instanceof Error)) {
+	          printWarning(
+	            (componentName || 'React class') + ': type specification of ' +
+	            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+	            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+	            'You may have forgotten to pass an argument to the type checker ' +
+	            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+	            'shape all require an argument).'
+	          );
+	        }
+	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	          // Only monitor this failure once because there tends to be a lot of the
+	          // same error.
+	          loggedTypeFailures[error.message] = true;
+
+	          var stack = getStack ? getStack() : '';
+
+	          printWarning(
+	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+	          );
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Resets warning cache when testing.
+	 *
+	 * @private
+	 */
+	checkPropTypes.resetWarningCache = function() {
+	  if (process.env.NODE_ENV !== 'production') {
+	    loggedTypeFailures = {};
+	  }
+	};
+
+	checkPropTypes_1 = checkPropTypes;
+	return checkPropTypes_1;
+}
+
+exports.__require = requireCheckPropTypes;

package/dist/cjs/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret.cjs');
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var factoryWithThrowingShims;
+var hasRequiredFactoryWithThrowingShims;
+
+function requireFactoryWithThrowingShims () {
+	if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+	hasRequiredFactoryWithThrowingShims = 1;
+
+	var ReactPropTypesSecret$1 = /*@__PURE__*/ ReactPropTypesSecret.__require();
+
+	function emptyFunction() {}
+	function emptyFunctionWithReset() {}
+	emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+	factoryWithThrowingShims = function() {
+	  function shim(props, propName, componentName, location, propFullName, secret) {
+	    if (secret === ReactPropTypesSecret$1) {
+	      // It is still safe when called from React.
+	      return;
+	    }
+	    var err = new Error(
+	      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+	      'Use PropTypes.checkPropTypes() to call them. ' +
+	      'Read more at http://fb.me/use-check-prop-types'
+	    );
+	    err.name = 'Invariant Violation';
+	    throw err;
+	  }	  shim.isRequired = shim;
+	  function getShim() {
+	    return shim;
+	  }	  // Important!
+	  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+	  var ReactPropTypes = {
+	    array: shim,
+	    bigint: shim,
+	    bool: shim,
+	    func: shim,
+	    number: shim,
+	    object: shim,
+	    string: shim,
+	    symbol: shim,
+
+	    any: shim,
+	    arrayOf: getShim,
+	    element: shim,
+	    elementType: shim,
+	    instanceOf: getShim,
+	    node: shim,
+	    objectOf: getShim,
+	    oneOf: getShim,
+	    oneOfType: getShim,
+	    shape: getShim,
+	    exact: getShim,
+
+	    checkPropTypes: emptyFunctionWithReset,
+	    resetWarningCache: emptyFunction
+	  };
+
+	  ReactPropTypes.PropTypes = ReactPropTypes;
+
+	  return ReactPropTypes;
+	};
+	return factoryWithThrowingShims;
+}
+
+exports.__require = requireFactoryWithThrowingShims;