umwd-components 0.1.757 → 0.1.758

package/dist/esm/node_modules/recharts/lib/util/DOMUtils.js

@@ -0,0 +1,93 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as DOMUtils } from '../../../../_virtual/DOMUtils.js';
+import './Global.js';
+import { __exports as Global } from '../../../../_virtual/Global.js';
+
+Object.defineProperty(DOMUtils, "__esModule", {
+  value: true
+});
+DOMUtils.getStringSize = void 0;
+var _Global = Global;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var stringCache = {
+  widthCache: {},
+  cacheCount: 0
+};
+var MAX_CACHE_NUM = 2000;
+var SPAN_STYLE = {
+  position: 'absolute',
+  top: '-20000px',
+  left: 0,
+  padding: 0,
+  margin: 0,
+  border: 'none',
+  whiteSpace: 'pre'
+};
+var MEASUREMENT_SPAN_ID = 'recharts_measurement_span';
+function removeInvalidKeys(obj) {
+  var copyObj = _objectSpread({}, obj);
+  Object.keys(copyObj).forEach(key => {
+    if (!copyObj[key]) {
+      delete copyObj[key];
+    }
+  });
+  return copyObj;
+}
+DOMUtils.getStringSize = function getStringSize(text) {
+  var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (text === undefined || text === null || _Global.Global.isSsr) {
+    return {
+      width: 0,
+      height: 0
+    };
+  }
+  var copyStyle = removeInvalidKeys(style);
+  var cacheKey = JSON.stringify({
+    text,
+    copyStyle
+  });
+  if (stringCache.widthCache[cacheKey]) {
+    return stringCache.widthCache[cacheKey];
+  }
+  try {
+    var measurementSpan = document.getElementById(MEASUREMENT_SPAN_ID);
+    if (!measurementSpan) {
+      measurementSpan = document.createElement('span');
+      measurementSpan.setAttribute('id', MEASUREMENT_SPAN_ID);
+      measurementSpan.setAttribute('aria-hidden', 'true');
+      document.body.appendChild(measurementSpan);
+    }
+    // Need to use CSS Object Model (CSSOM) to be able to comply with Content Security Policy (CSP)
+    // https://en.wikipedia.org/wiki/Content_Security_Policy
+    var measurementSpanStyle = _objectSpread(_objectSpread({}, SPAN_STYLE), copyStyle);
+    Object.assign(measurementSpan.style, measurementSpanStyle);
+    measurementSpan.textContent = "".concat(text);
+    var rect = measurementSpan.getBoundingClientRect();
+    var result = {
+      width: rect.width,
+      height: rect.height
+    };
+    stringCache.widthCache[cacheKey] = result;
+    if (++stringCache.cacheCount > MAX_CACHE_NUM) {
+      stringCache.cacheCount = 0;
+      stringCache.widthCache = {};
+    }
+    return result;
+  } catch (_unused) {
+    return {
+      width: 0,
+      height: 0
+    };
+  }
+};
+
+export { DOMUtils as default };

package/dist/esm/node_modules/recharts/lib/util/DataUtils.js

@@ -0,0 +1,184 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as DataUtils } from '../../../../_virtual/DataUtils.js';
+import { g as get } from '../../../es-toolkit/compat/get.js';
+
+Object.defineProperty(DataUtils, "__esModule", {
+  value: true
+});
+DataUtils.findEntryInArray = findEntryInArray;
+DataUtils.hasDuplicate = DataUtils.getPercentValue = DataUtils.getLinearRegression = void 0;
+DataUtils.interpolate = interpolate;
+DataUtils.upperFirst = DataUtils.uniqueId = DataUtils.mathSign = DataUtils.isPercent = DataUtils.isNumber = DataUtils.isNumOrStr = DataUtils.isNullish = DataUtils.isNan = DataUtils.interpolateNumber = void 0;
+var _get = _interopRequireDefault(get);
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var mathSign = value => {
+  if (value === 0) {
+    return 0;
+  }
+  if (value > 0) {
+    return 1;
+  }
+  return -1;
+};
+DataUtils.mathSign = mathSign;
+var isNan = value => {
+  // eslint-disable-next-line eqeqeq
+  return typeof value == 'number' && value != +value;
+};
+DataUtils.isNan = isNan;
+var isPercent = value => typeof value === 'string' && value.indexOf('%') === value.length - 1;
+DataUtils.isPercent = isPercent;
+var isNumber = value => (typeof value === 'number' || value instanceof Number) && !isNan(value);
+DataUtils.isNumber = isNumber;
+var isNumOrStr = value => isNumber(value) || typeof value === 'string';
+DataUtils.isNumOrStr = isNumOrStr;
+var idCounter = 0;
+var uniqueId = prefix => {
+  var id = ++idCounter;
+  return "".concat(prefix || '').concat(id);
+};
+
+/**
+ * Get percent value of a total value
+ * @param {number|string} percent A percent
+ * @param {number} totalValue     Total value
+ * @param {number} defaultValue   The value returned when percent is undefined or invalid
+ * @param {boolean} validate      If set to be true, the result will be validated
+ * @return {number} value
+ */
+DataUtils.uniqueId = uniqueId;
+DataUtils.getPercentValue = function getPercentValue(percent, totalValue) {
+  var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var validate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!isNumber(percent) && typeof percent !== 'string') {
+    return defaultValue;
+  }
+  var value;
+  if (isPercent(percent)) {
+    if (totalValue == null) {
+      return defaultValue;
+    }
+    var index = percent.indexOf('%');
+    value = totalValue * parseFloat(percent.slice(0, index)) / 100;
+  } else {
+    value = +percent;
+  }
+  if (isNan(value)) {
+    value = defaultValue;
+  }
+  if (validate && totalValue != null && value > totalValue) {
+    value = totalValue;
+  }
+  return value;
+};
+var hasDuplicate = ary => {
+  if (!Array.isArray(ary)) {
+    return false;
+  }
+  var len = ary.length;
+  var cache = {};
+  for (var i = 0; i < len; i++) {
+    if (!cache[ary[i]]) {
+      cache[ary[i]] = true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * @deprecated instead use {@link interpolate}
+ *  this function returns a function that is called immediately in all use-cases.
+ *  Instead, use interpolate which returns a number and skips the anonymous function step.
+ *  @param numberA The first number
+ *  @param numberB The second number
+ *  @return A function that returns the interpolated number
+ */
+DataUtils.hasDuplicate = hasDuplicate;
+var interpolateNumber = (numberA, numberB) => {
+  if (isNumber(numberA) && isNumber(numberB)) {
+    return t => numberA + t * (numberB - numberA);
+  }
+  return () => numberB;
+};
+DataUtils.interpolateNumber = interpolateNumber;
+function interpolate(start, end, t) {
+  if (isNumber(start) && isNumber(end)) {
+    return start + t * (end - start);
+  }
+  return end;
+}
+function findEntryInArray(ary, specifiedKey, specifiedValue) {
+  if (!ary || !ary.length) {
+    return undefined;
+  }
+  return ary.find(entry => entry && (typeof specifiedKey === 'function' ? specifiedKey(entry) : (0, _get.default)(entry, specifiedKey)) === specifiedValue);
+}
+
+/**
+ * The least square linear regression
+ * @param {Array} data The array of points
+ * @returns {Object} The domain of x, and the parameter of linear function
+ */
+var getLinearRegression = data => {
+  if (!data || !data.length) {
+    return null;
+  }
+  var len = data.length;
+  var xsum = 0;
+  var ysum = 0;
+  var xysum = 0;
+  var xxsum = 0;
+  var xmin = Infinity;
+  var xmax = -Infinity;
+  var xcurrent = 0;
+  var ycurrent = 0;
+  for (var i = 0; i < len; i++) {
+    xcurrent = data[i].cx || 0;
+    ycurrent = data[i].cy || 0;
+    xsum += xcurrent;
+    ysum += ycurrent;
+    xysum += xcurrent * ycurrent;
+    xxsum += xcurrent * xcurrent;
+    xmin = Math.min(xmin, xcurrent);
+    xmax = Math.max(xmax, xcurrent);
+  }
+  var a = len * xxsum !== xsum * xsum ? (len * xysum - xsum * ysum) / (len * xxsum - xsum * xsum) : 0;
+  return {
+    xmin,
+    xmax,
+    a,
+    b: (ysum - a * xsum) / len
+  };
+};
+DataUtils.getLinearRegression = getLinearRegression;
+/**
+ * Checks if the value is null or undefined
+ * @param value The value to check
+ * @returns true if the value is null or undefined
+ */
+var isNullish = value => {
+  return value === null || typeof value === 'undefined';
+};
+
+/**
+ *Uppercase the first letter of a string
+ * @param {string} value The string to uppercase
+ * @returns {string} The uppercased string
+ */
+DataUtils.isNullish = isNullish;
+var upperFirst = value => {
+  if (isNullish(value)) {
+    return value;
+  }
+  return "".concat(value.charAt(0).toUpperCase()).concat(value.slice(1));
+};
+DataUtils.upperFirst = upperFirst;
+
+export { DataUtils as default };

package/dist/esm/node_modules/recharts/lib/util/Events.js

@@ -0,0 +1,20 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Events } from '../../../../_virtual/Events.js';
+import { e as eventemitter3Exports } from '../../node_modules/eventemitter3/index.js';
+
+Object.defineProperty(Events, "__esModule", {
+  value: true
+});
+Events.eventCenter = Events.TOOLTIP_SYNC_EVENT = Events.BRUSH_SYNC_EVENT = void 0;
+var _eventemitter = _interopRequireDefault(eventemitter3Exports);
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+Events.eventCenter = new _eventemitter.default();
+Events.TOOLTIP_SYNC_EVENT = 'recharts.syncEvent.tooltip';
+Events.BRUSH_SYNC_EVENT = 'recharts.syncEvent.brush';
+
+export { Events as default };

package/dist/esm/node_modules/recharts/lib/util/Global.js

@@ -0,0 +1,18 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Global } from '../../../../_virtual/Global.js';
+
+Object.defineProperty(Global, "__esModule", {
+  value: true
+});
+Global.Global = void 0;
+var parseIsSsrByDefault = () => !(typeof window !== 'undefined' && window.document && Boolean(window.document.createElement) && window.setTimeout);
+Global.Global = {
+  isSsr: parseIsSsrByDefault()
+};
+
+export { Global as default };

package/dist/esm/node_modules/recharts/lib/util/PolarUtils.js

@@ -0,0 +1,165 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as PolarUtils } from '../../../../_virtual/PolarUtils.js';
+import require$$0 from 'react';
+
+Object.defineProperty(PolarUtils, "__esModule", {
+  value: true
+});
+PolarUtils.radianToDegree = PolarUtils.polarToCartesian = PolarUtils.inRangeOfSector = PolarUtils.getTickClassName = PolarUtils.getMaxRadius = PolarUtils.getAngleOfPoint = PolarUtils.formatAngleOfSector = PolarUtils.distanceBetweenPoints = PolarUtils.degreeToRadian = PolarUtils.RADIAN = void 0;
+var _react = require$$0;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var RADIAN = PolarUtils.RADIAN = Math.PI / 180;
+var degreeToRadian = angle => angle * Math.PI / 180;
+PolarUtils.degreeToRadian = degreeToRadian;
+var radianToDegree = angleInRadian => angleInRadian * 180 / Math.PI;
+PolarUtils.radianToDegree = radianToDegree;
+var polarToCartesian = (cx, cy, radius, angle) => ({
+  x: cx + Math.cos(-RADIAN * angle) * radius,
+  y: cy + Math.sin(-RADIAN * angle) * radius
+});
+PolarUtils.polarToCartesian = polarToCartesian;
+PolarUtils.getMaxRadius = function getMaxRadius(width, height) {
+  var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0};
+  return Math.min(Math.abs(width - (offset.left || 0) - (offset.right || 0)), Math.abs(height - (offset.top || 0) - (offset.bottom || 0))) / 2;
+};
+var distanceBetweenPoints = (point, anotherPoint) => {
+  var {
+    x: x1,
+    y: y1
+  } = point;
+  var {
+    x: x2,
+    y: y2
+  } = anotherPoint;
+  return Math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2);
+};
+PolarUtils.distanceBetweenPoints = distanceBetweenPoints;
+var getAngleOfPoint = (_ref, _ref2) => {
+  var {
+    x,
+    y
+  } = _ref;
+  var {
+    cx,
+    cy
+  } = _ref2;
+  var radius = distanceBetweenPoints({
+    x,
+    y
+  }, {
+    x: cx,
+    y: cy
+  });
+  if (radius <= 0) {
+    return {
+      radius,
+      angle: 0
+    };
+  }
+  var cos = (x - cx) / radius;
+  var angleInRadian = Math.acos(cos);
+  if (y > cy) {
+    angleInRadian = 2 * Math.PI - angleInRadian;
+  }
+  return {
+    radius,
+    angle: radianToDegree(angleInRadian),
+    angleInRadian
+  };
+};
+PolarUtils.getAngleOfPoint = getAngleOfPoint;
+var formatAngleOfSector = _ref3 => {
+  var {
+    startAngle,
+    endAngle
+  } = _ref3;
+  var startCnt = Math.floor(startAngle / 360);
+  var endCnt = Math.floor(endAngle / 360);
+  var min = Math.min(startCnt, endCnt);
+  return {
+    startAngle: startAngle - min * 360,
+    endAngle: endAngle - min * 360
+  };
+};
+PolarUtils.formatAngleOfSector = formatAngleOfSector;
+var reverseFormatAngleOfSector = (angle, _ref4) => {
+  var {
+    startAngle,
+    endAngle
+  } = _ref4;
+  var startCnt = Math.floor(startAngle / 360);
+  var endCnt = Math.floor(endAngle / 360);
+  var min = Math.min(startCnt, endCnt);
+  return angle + min * 360;
+};
+var inRangeOfSector = (_ref5, viewBox) => {
+  var {
+    x,
+    y
+  } = _ref5;
+  var {
+    radius,
+    angle
+  } = getAngleOfPoint({
+    x,
+    y
+  }, viewBox);
+  var {
+    innerRadius,
+    outerRadius
+  } = viewBox;
+  if (radius < innerRadius || radius > outerRadius) {
+    return null;
+  }
+  if (radius === 0) {
+    return null;
+  }
+  var {
+    startAngle,
+    endAngle
+  } = formatAngleOfSector(viewBox);
+  var formatAngle = angle;
+  var inRange;
+  if (startAngle <= endAngle) {
+    while (formatAngle > endAngle) {
+      formatAngle -= 360;
+    }
+    while (formatAngle < startAngle) {
+      formatAngle += 360;
+    }
+    inRange = formatAngle >= startAngle && formatAngle <= endAngle;
+  } else {
+    while (formatAngle > startAngle) {
+      formatAngle -= 360;
+    }
+    while (formatAngle < endAngle) {
+      formatAngle += 360;
+    }
+    inRange = formatAngle >= endAngle && formatAngle <= startAngle;
+  }
+  if (inRange) {
+    return _objectSpread(_objectSpread({}, viewBox), {}, {
+      radius,
+      angle: reverseFormatAngleOfSector(formatAngle, viewBox)
+    });
+  }
+  return null;
+};
+PolarUtils.inRangeOfSector = inRangeOfSector;
+var getTickClassName = tick => ! /*#__PURE__*/(0, _react.isValidElement)(tick) && typeof tick !== 'function' && typeof tick !== 'boolean' && tick != null ? tick.className : '';
+PolarUtils.getTickClassName = getTickClassName;
+
+export { PolarUtils as default };

package/dist/esm/node_modules/recharts/lib/util/ReactUtils.js

@@ -0,0 +1,162 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as ReactUtils } from '../../../../_virtual/ReactUtils.js';
+import { g as get } from '../../../es-toolkit/compat/get.js';
+import require$$0 from 'react';
+import { r as reactIsExports } from '../../../react-is/index.js';
+import './DataUtils.js';
+import './types.js';
+import { __exports as DataUtils } from '../../../../_virtual/DataUtils.js';
+import { __exports as types } from '../../../../_virtual/types.js';
+
+Object.defineProperty(ReactUtils, "__esModule", {
+  value: true
+});
+ReactUtils.filterProps = ReactUtils.SCALE_TYPES = void 0;
+ReactUtils.findAllByType = findAllByType;
+ReactUtils.toArray = ReactUtils.isValidSpreadableProp = ReactUtils.isClipDot = ReactUtils.getDisplayName = void 0;
+var _get = _interopRequireDefault(get);
+var _react = require$$0;
+var _reactIs = reactIsExports;
+var _DataUtils = DataUtils;
+var _types = types;
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+ReactUtils.SCALE_TYPES = ['auto', 'linear', 'pow', 'sqrt', 'log', 'identity', 'time', 'band', 'point', 'ordinal', 'quantile', 'quantize', 'utc', 'sequential', 'threshold'];
+
+/**
+ * @deprecated instead find another approach that does not depend on displayName.
+ * Get the display name of a component
+ * @param  {Object} Comp Specified Component
+ * @return {String}      Display name of Component
+ */
+var getDisplayName = Comp => {
+  if (typeof Comp === 'string') {
+    return Comp;
+  }
+  if (!Comp) {
+    return '';
+  }
+  return Comp.displayName || Comp.name || 'Component';
+};
+
+// `toArray` gets called multiple times during the render
+// so we can memoize last invocation (since reference to `children` is the same)
+ReactUtils.getDisplayName = getDisplayName;
+var lastChildren = null;
+var lastResult = null;
+
+/**
+ * @deprecated instead find another approach that does not require reading React Elements from DOM.
+ *
+ * @param children do not use
+ * @return deprecated do not use
+ */
+var toArray = children => {
+  if (children === lastChildren && Array.isArray(lastResult)) {
+    return lastResult;
+  }
+  var result = [];
+  _react.Children.forEach(children, child => {
+    if ((0, _DataUtils.isNullish)(child)) return;
+    if ((0, _reactIs.isFragment)(child)) {
+      result = result.concat(toArray(child.props.children));
+    } else {
+      // @ts-expect-error this could still be Iterable<ReactNode> and TS does not like that
+      result.push(child);
+    }
+  });
+  lastResult = result;
+  lastChildren = children;
+  return result;
+};
+
+/**
+ * @deprecated instead find another approach that does not require reading React Elements from DOM.
+ *
+ * Find and return all matched children by type.
+ * `type` must be a React.ComponentType
+ *
+ * @param children do not use
+ * @param type do not use
+ * @return deprecated do not use
+ */
+ReactUtils.toArray = toArray;
+function findAllByType(children, type) {
+  var result = [];
+  var types = [];
+  if (Array.isArray(type)) {
+    types = type.map(t => getDisplayName(t));
+  } else {
+    types = [getDisplayName(type)];
+  }
+  toArray(children).forEach(child => {
+    var childType = (0, _get.default)(child, 'type.displayName') || (0, _get.default)(child, 'type.name');
+    // ts-expect-error toArray and lodash.get are not compatible. Let's get rid of the whole findAllByType function
+    if (types.indexOf(childType) !== -1) {
+      result.push(child);
+    }
+  });
+  return result;
+}
+var isClipDot = dot => {
+  if (dot && typeof dot === 'object' && 'clipDot' in dot) {
+    return Boolean(dot.clipDot);
+  }
+  return true;
+};
+
+/**
+ * Checks if the property is valid to spread onto an SVG element or onto a specific component
+ * @param {unknown} property property value currently being compared
+ * @param {string} key property key currently being compared
+ * @param {boolean} includeEvents if events are included in spreadable props
+ * @param {boolean} svgElementType checks against map of SVG element types to attributes
+ * @returns {boolean} is prop valid
+ */
+ReactUtils.isClipDot = isClipDot;
+var isValidSpreadableProp = (property, key, includeEvents, svgElementType) => {
+  var _ref;
+  /**
+   * If the svg element type is explicitly included, check against the filtered element key map
+   * to determine if there are attributes that should only exist on that element type.
+   * @todo Add an internal cjs version of https://github.com/wooorm/svg-element-attributes for full coverage.
+   */
+  var matchingElementTypeKeys = (_ref = svgElementType && (_types.FilteredElementKeyMap === null || _types.FilteredElementKeyMap === void 0 ? void 0 : _types.FilteredElementKeyMap[svgElementType])) !== null && _ref !== void 0 ? _ref : [];
+  return key.startsWith('data-') || typeof property !== 'function' && (svgElementType && matchingElementTypeKeys.includes(key) || _types.SVGElementPropKeys.includes(key)) || includeEvents && _types.EventKeys.includes(key);
+};
+ReactUtils.isValidSpreadableProp = isValidSpreadableProp;
+var filterProps = (props, includeEvents, svgElementType) => {
+  if (!props || typeof props === 'function' || typeof props === 'boolean') {
+    return null;
+  }
+  var inputProps = props;
+  if (/*#__PURE__*/(0, _react.isValidElement)(props)) {
+    inputProps = props.props;
+  }
+  if (typeof inputProps !== 'object' && typeof inputProps !== 'function') {
+    return null;
+  }
+  var out = {};
+
+  /**
+   * Props are blindly spread onto SVG elements. This loop filters out properties that we don't want to spread.
+   * Items filtered out are as follows:
+   *   - functions in properties that are SVG attributes (functions are included when includeEvents is true)
+   *   - props that are SVG attributes but don't matched the passed svgElementType
+   *   - any prop that is not in SVGElementPropKeys (or in EventKeys if includeEvents is true)
+   */
+  Object.keys(inputProps).forEach(key => {
+    var _inputProps;
+    if (isValidSpreadableProp((_inputProps = inputProps) === null || _inputProps === void 0 ? void 0 : _inputProps[key], key, includeEvents, svgElementType)) {
+      out[key] = inputProps[key];
+    }
+  });
+  return out;
+};
+ReactUtils.filterProps = filterProps;
+
+export { ReactUtils as default };