@octanejs/recharts 0.1.0

package/src/util/ReactUtils.ts

@@ -0,0 +1,94 @@
+// Port of util/ReactUtils.tsx on octane's element-descriptor introspection
+// (octane `Children`/`isValidElement` operate on descriptor values — arrays,
+// single descriptors, primitives). NOTE the octane children model: STATIC JSX
+// children compile to an opaque block function, which cannot be introspected —
+// these helpers see descriptors only where children arrive as VALUES (arrays
+// from .map(), elements passed through props). recharts' remaining
+// children-introspection site (Cell) is ported to context REGISTRATION instead
+// (see component/Cell), matching the redux-registration pattern recharts v3
+// itself adopted for everything else.
+import { Children } from 'octane';
+import { isNullish } from './DataUtils';
+
+export const 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.
+ */
+export const getDisplayName = (Comp: unknown): string => {
+	if (typeof Comp === 'string') {
+		return Comp;
+	}
+	if (!Comp) {
+		return '';
+	}
+	return (Comp as any).displayName || (Comp as any).name || 'Component';
+};
+
+// `toArray` gets called multiple times during the render
+// so we can memoize last invocation (since reference to `children` is the same)
+let lastChildren: unknown = null;
+let lastResult: any[] | null = null;
+
+/**
+ * @deprecated instead find another approach that does not require reading elements from children.
+ */
+export const toArray = (children: unknown): any[] => {
+	if (children === lastChildren && Array.isArray(lastResult)) {
+		return lastResult;
+	}
+	const result: any[] = [];
+	Children.forEach(children, (child: unknown) => {
+		if (isNullish(child)) return;
+		result.push(child);
+	});
+	lastResult = result;
+	lastChildren = children;
+	return result;
+};
+
+/**
+ * @deprecated instead find another approach that does not require reading elements from children.
+ *
+ * Find and return all matched children by type (descriptor-valued children only —
+ * see the module note).
+ */
+export function findAllByType(children: unknown, type: unknown | unknown[]): any[] {
+	const result: any[] = [];
+	let types: string[] = [];
+	if (Array.isArray(type)) {
+		types = type.map((t) => getDisplayName(t));
+	} else {
+		types = [getDisplayName(type)];
+	}
+	toArray(children).forEach((child) => {
+		const childType = child?.type?.displayName || child?.type?.name;
+		if (childType && types.indexOf(childType) !== -1) {
+			result.push(child);
+		}
+	});
+	return result;
+}
+
+export const isClipDot = (dot: unknown): boolean => {
+	if (dot && typeof dot === 'object' && 'clipDot' in dot) {
+		return Boolean((dot as any).clipDot);
+	}
+	return true;
+};

package/src/util/ReduceCSSCalc.js

@@ -0,0 +1,260 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/ReduceCSSCalc.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+var _DecimalCSS;
+function _slicedToArray(r, e) {
+	return (
+		_arrayWithHoles(r) ||
+		_iterableToArrayLimit(r, e) ||
+		_unsupportedIterableToArray(r, e) ||
+		_nonIterableRest()
+	);
+}
+function _nonIterableRest() {
+	throw new TypeError(
+		'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
+	);
+}
+function _unsupportedIterableToArray(r, a) {
+	if (r) {
+		if ('string' == typeof r) return _arrayLikeToArray(r, a);
+		var t = {}.toString.call(r).slice(8, -1);
+		return (
+			'Object' === t && r.constructor && (t = r.constructor.name),
+			'Map' === t || 'Set' === t
+				? Array.from(r)
+				: 'Arguments' === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
+					? _arrayLikeToArray(r, a)
+					: void 0
+		);
+	}
+}
+function _arrayLikeToArray(r, a) {
+	(null == a || a > r.length) && (a = r.length);
+	for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+	return n;
+}
+function _iterableToArrayLimit(r, l) {
+	var t =
+		null == r ? null : ('undefined' != typeof Symbol && r[Symbol.iterator]) || r['@@iterator'];
+	if (null != t) {
+		var e,
+			n,
+			i,
+			u,
+			a = [],
+			f = !0,
+			o = !1;
+		try {
+			if (((i = (t = t.call(r)).next), 0 === l)) {
+				if (Object(t) !== t) return;
+				f = !1;
+			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+		} catch (r) {
+			((o = !0), (n = r));
+		} finally {
+			try {
+				if (!f && null != t.return && ((u = t.return()), Object(u) !== u)) return;
+			} finally {
+				if (o) throw n;
+			}
+		}
+		return a;
+	}
+}
+function _arrayWithHoles(r) {
+	if (Array.isArray(r)) return r;
+}
+function _defineProperty(e, r, t) {
+	return (
+		(r = _toPropertyKey(r)) in e
+			? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 })
+			: (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 || 'default');
+		if ('object' != typeof i) return i;
+		throw new TypeError('@@toPrimitive must return a primitive value.');
+	}
+	return ('string' === r ? String : Number)(t);
+}
+import { isNan } from './DataUtils';
+var MULTIPLY_OR_DIVIDE_REGEX = /(-?\d+(?:\.\d+)?[a-zA-Z%]*)([*/])(-?\d+(?:\.\d+)?[a-zA-Z%]*)/;
+var ADD_OR_SUBTRACT_REGEX = /(-?\d+(?:\.\d+)?[a-zA-Z%]*)([+-])(-?\d+(?:\.\d+)?[a-zA-Z%]*)/;
+var CSS_LENGTH_UNIT_REGEX = /^(px|cm|vh|vw|em|rem|%|mm|in|pt|pc|ex|ch|vmin|vmax|Q)$/;
+var NUM_SPLIT_REGEX = /(-?\d+(?:\.\d+)?)([a-zA-Z%]+)?/;
+var CONVERSION_RATES = {
+	cm: 96 / 2.54,
+	mm: 96 / 25.4,
+	pt: 96 / 72,
+	pc: 96 / 6,
+	in: 96,
+	Q: 96 / (2.54 * 40),
+	px: 1,
+};
+var FIXED_CSS_LENGTH_UNITS = ['cm', 'mm', 'pt', 'pc', 'in', 'Q', 'px'];
+function isSupportedUnit(unit) {
+	return FIXED_CSS_LENGTH_UNITS.includes(unit);
+}
+var STR_NAN = 'NaN';
+function convertToPx(value, unit) {
+	return value * CONVERSION_RATES[unit];
+}
+class DecimalCSS {
+	static parse(str) {
+		var _NUM_SPLIT_REGEX$exec;
+		var _ref =
+				(_NUM_SPLIT_REGEX$exec = NUM_SPLIT_REGEX.exec(str)) !== null &&
+				_NUM_SPLIT_REGEX$exec !== void 0
+					? _NUM_SPLIT_REGEX$exec
+					: [],
+			_ref2 = _slicedToArray(_ref, 3),
+			numStr = _ref2[1],
+			unit = _ref2[2];
+		if (numStr == null) {
+			return DecimalCSS.NaN;
+		}
+		return new DecimalCSS(parseFloat(numStr), unit !== null && unit !== void 0 ? unit : '');
+	}
+	constructor(num, unit) {
+		this.num = num;
+		this.unit = unit;
+		this.num = num;
+		this.unit = unit;
+		if (isNan(num)) {
+			this.unit = '';
+		}
+		if (unit !== '' && !CSS_LENGTH_UNIT_REGEX.test(unit)) {
+			this.num = NaN;
+			this.unit = '';
+		}
+		if (isSupportedUnit(unit)) {
+			this.num = convertToPx(num, unit);
+			this.unit = 'px';
+		}
+	}
+	add(other) {
+		if (this.unit !== other.unit) {
+			return new DecimalCSS(NaN, '');
+		}
+		return new DecimalCSS(this.num + other.num, this.unit);
+	}
+	subtract(other) {
+		if (this.unit !== other.unit) {
+			return new DecimalCSS(NaN, '');
+		}
+		return new DecimalCSS(this.num - other.num, this.unit);
+	}
+	multiply(other) {
+		if (this.unit !== '' && other.unit !== '' && this.unit !== other.unit) {
+			return new DecimalCSS(NaN, '');
+		}
+		return new DecimalCSS(this.num * other.num, this.unit || other.unit);
+	}
+	divide(other) {
+		if (this.unit !== '' && other.unit !== '' && this.unit !== other.unit) {
+			return new DecimalCSS(NaN, '');
+		}
+		return new DecimalCSS(this.num / other.num, this.unit || other.unit);
+	}
+	toString() {
+		return ''.concat(this.num).concat(this.unit);
+	}
+	isNaN() {
+		return isNan(this.num);
+	}
+}
+_DecimalCSS = DecimalCSS;
+_defineProperty(DecimalCSS, 'NaN', new _DecimalCSS(NaN, ''));
+function calculateArithmetic(expr) {
+	if (expr == null || expr.includes(STR_NAN)) {
+		return STR_NAN;
+	}
+	var newExpr = expr;
+	while (newExpr.includes('*') || newExpr.includes('/')) {
+		var _MULTIPLY_OR_DIVIDE_R;
+		var _ref3 =
+				(_MULTIPLY_OR_DIVIDE_R = MULTIPLY_OR_DIVIDE_REGEX.exec(newExpr)) !== null &&
+				_MULTIPLY_OR_DIVIDE_R !== void 0
+					? _MULTIPLY_OR_DIVIDE_R
+					: [],
+			_ref4 = _slicedToArray(_ref3, 4),
+			leftOperand = _ref4[1],
+			operator = _ref4[2],
+			rightOperand = _ref4[3];
+		var lTs = DecimalCSS.parse(leftOperand !== null && leftOperand !== void 0 ? leftOperand : '');
+		var rTs = DecimalCSS.parse(
+			rightOperand !== null && rightOperand !== void 0 ? rightOperand : '',
+		);
+		var result = operator === '*' ? lTs.multiply(rTs) : lTs.divide(rTs);
+		if (result.isNaN()) {
+			return STR_NAN;
+		}
+		newExpr = newExpr.replace(MULTIPLY_OR_DIVIDE_REGEX, result.toString());
+	}
+	while (newExpr.includes('+') || /.-\d+(?:\.\d+)?/.test(newExpr)) {
+		var _ADD_OR_SUBTRACT_REGE;
+		var _ref5 =
+				(_ADD_OR_SUBTRACT_REGE = ADD_OR_SUBTRACT_REGEX.exec(newExpr)) !== null &&
+				_ADD_OR_SUBTRACT_REGE !== void 0
+					? _ADD_OR_SUBTRACT_REGE
+					: [],
+			_ref6 = _slicedToArray(_ref5, 4),
+			_leftOperand = _ref6[1],
+			_operator = _ref6[2],
+			_rightOperand = _ref6[3];
+		var _lTs = DecimalCSS.parse(
+			_leftOperand !== null && _leftOperand !== void 0 ? _leftOperand : '',
+		);
+		var _rTs = DecimalCSS.parse(
+			_rightOperand !== null && _rightOperand !== void 0 ? _rightOperand : '',
+		);
+		var _result = _operator === '+' ? _lTs.add(_rTs) : _lTs.subtract(_rTs);
+		if (_result.isNaN()) {
+			return STR_NAN;
+		}
+		newExpr = newExpr.replace(ADD_OR_SUBTRACT_REGEX, _result.toString());
+	}
+	return newExpr;
+}
+var PARENTHESES_REGEX = /\(([^()]*)\)/;
+function calculateParentheses(expr) {
+	var newExpr = expr;
+	var match;
+	// eslint-disable-next-line no-cond-assign
+	while ((match = PARENTHESES_REGEX.exec(newExpr)) != null) {
+		var _match = match,
+			_match2 = _slicedToArray(_match, 2),
+			parentheticalExpression = _match2[1];
+		newExpr = newExpr.replace(PARENTHESES_REGEX, calculateArithmetic(parentheticalExpression));
+	}
+	return newExpr;
+}
+function evaluateExpression(expression) {
+	var newExpr = expression.replace(/\s+/g, '');
+	newExpr = calculateParentheses(newExpr);
+	newExpr = calculateArithmetic(newExpr);
+	return newExpr;
+}
+export function safeEvaluateExpression(expression) {
+	try {
+		return evaluateExpression(expression);
+	} catch (_unused) {
+		return STR_NAN;
+	}
+}
+export function reduceCSSCalc(expression) {
+	var result = safeEvaluateExpression(expression.slice(5, -1));
+	if (result === STR_NAN) {
+		return '';
+	}
+	return result;
+}

package/src/util/TickUtils.js

@@ -0,0 +1,43 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/TickUtils.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { getAngledRectangleWidth } from './CartesianUtils';
+import { getEveryNth } from './getEveryNth';
+export function getAngledTickWidth(contentSize, unitSize, angle) {
+	var size = {
+		width: contentSize.width + unitSize.width,
+		height: contentSize.height + unitSize.height,
+	};
+	return getAngledRectangleWidth(size, angle);
+}
+export function getTickBoundaries(viewBox, sign, sizeKey) {
+	var isWidth = sizeKey === 'width';
+	var x = viewBox.x,
+		y = viewBox.y,
+		width = viewBox.width,
+		height = viewBox.height;
+	if (sign === 1) {
+		return {
+			start: isWidth ? x : y,
+			end: isWidth ? x + width : y + height,
+		};
+	}
+	return {
+		start: isWidth ? x + width : y + height,
+		end: isWidth ? x : y,
+	};
+}
+export function isVisible(sign, tickPosition, getSize, start, end) {
+	/* Since getSize() is expensive (it reads the ticks' size from the DOM), we do this check first to avoid calculating
+	 * the tick's size. */
+	if (sign * tickPosition < sign * start || sign * tickPosition > sign * end) {
+		return false;
+	}
+	var size = getSize();
+	return (
+		sign * (tickPosition - (sign * size) / 2 - start) >= 0 &&
+		sign * (tickPosition + (sign * size) / 2 - end) <= 0
+	);
+}
+export function getNumberIntervalTicks(ticks, interval) {
+	return getEveryNth(ticks, interval + 1);
+}

package/src/util/YAxisUtils.js

@@ -0,0 +1,43 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/YAxisUtils.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+/**
+ * Calculates the width of the Y-axis based on the tick labels and the axis label.
+ * @param params - The parameters object.
+ * @param [params.ticks] - An array-like object of tick elements, each with a `getBoundingClientRect` method.
+ * @param [params.label] - The axis label element, with a `getBoundingClientRect` method.
+ * @param [params.labelGapWithTick=5] - The gap between the label and the tick.
+ * @param [params.tickSize=0] - The length of the tick line.
+ * @param [params.tickMargin=0] - The margin between the tick line and the tick text.
+ * @returns The calculated width of the Y-axis.
+ */
+export var getCalculatedYAxisWidth = (_ref) => {
+	var ticks = _ref.ticks,
+		label = _ref.label,
+		_ref$labelGapWithTick = _ref.labelGapWithTick,
+		labelGapWithTick = _ref$labelGapWithTick === void 0 ? 5 : _ref$labelGapWithTick,
+		_ref$tickSize = _ref.tickSize,
+		tickSize = _ref$tickSize === void 0 ? 0 : _ref$tickSize,
+		_ref$tickMargin = _ref.tickMargin,
+		tickMargin = _ref$tickMargin === void 0 ? 0 : _ref$tickMargin;
+	// find the max width of the tick labels
+	var maxTickWidth = 0;
+	if (ticks) {
+		Array.from(ticks).forEach((tickNode) => {
+			if (tickNode) {
+				var bbox = tickNode.getBoundingClientRect();
+				if (bbox.width > maxTickWidth) {
+					maxTickWidth = bbox.width;
+				}
+			}
+		});
+
+		// calculate width of the axis label
+		var labelWidth = label ? label.getBoundingClientRect().width : 0;
+		var tickWidth = tickSize + tickMargin;
+
+		// calculate the updated width of the y-axis
+		var updatedYAxisWidth = maxTickWidth + tickWidth + labelWidth + (label ? labelGapWithTick : 0);
+		return Math.round(updatedYAxisWidth);
+	}
+	return 0;
+};

package/src/util/axisPropsAreEqual.js

@@ -0,0 +1,63 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/axisPropsAreEqual.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+var _excluded = ['domain', 'range'],
+	_excluded2 = ['domain', 'range'];
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o,
+		r,
+		i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var n = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < n.length; r++)
+			((o = n[r]), -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]));
+	}
+	return i;
+}
+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;
+}
+import { propsAreEqual } from './propsAreEqual';
+function shortArraysAreEqual(arr1, arr2) {
+	if (arr1 === arr2) {
+		return true;
+	}
+	if (Array.isArray(arr1) && arr1.length === 2 && Array.isArray(arr2) && arr2.length === 2) {
+		return arr1[0] === arr2[0] && arr1[1] === arr2[1];
+	}
+	return false;
+}
+
+/**
+ * Usually we would not compare array props deeply for performance consideration.
+ * However, for axis props, domain is sometimes defined as a two-elements array, and range is always
+ * a two-elements array. So we can do a shallow comparison for the rest props and a shallow
+ * comparison for these two array props.
+ * @param prevProps
+ * @param nextProps
+ */
+export function axisPropsAreEqual(prevProps, nextProps) {
+	if (prevProps === nextProps) {
+		return true;
+	}
+	var prevDomain = prevProps.domain,
+		prevRange = prevProps.range,
+		prevRest = _objectWithoutProperties(prevProps, _excluded);
+	var nextDomain = nextProps.domain,
+		nextRange = nextProps.range,
+		nextRest = _objectWithoutProperties(nextProps, _excluded2);
+	if (!shortArraysAreEqual(prevDomain, nextDomain)) {
+		return false;
+	}
+	if (!shortArraysAreEqual(prevRange, nextRange)) {
+		return false;
+	}
+	return propsAreEqual(prevRest, nextRest);
+}

package/src/util/createEventProxy.js

@@ -0,0 +1,18 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/createEventProxy.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export function createEventProxy(reactEvent) {
+	reactEvent.persist();
+	var currentTarget = reactEvent.currentTarget;
+	return new Proxy(reactEvent, {
+		get: (target, prop) => {
+			if (prop === 'currentTarget') {
+				return currentTarget;
+			}
+			var value = Reflect.get(target, prop);
+			if (typeof value === 'function') {
+				return value.bind(target);
+			}
+			return value;
+		},
+	});
+}

package/src/util/excludeEventProps.js

@@ -0,0 +1,172 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/excludeEventProps.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+var EventKeys = [
+	'dangerouslySetInnerHTML',
+	'onCopy',
+	'onCopyCapture',
+	'onCut',
+	'onCutCapture',
+	'onPaste',
+	'onPasteCapture',
+	'onCompositionEnd',
+	'onCompositionEndCapture',
+	'onCompositionStart',
+	'onCompositionStartCapture',
+	'onCompositionUpdate',
+	'onCompositionUpdateCapture',
+	'onFocus',
+	'onFocusCapture',
+	'onBlur',
+	'onBlurCapture',
+	'onChange',
+	'onChangeCapture',
+	'onBeforeInput',
+	'onBeforeInputCapture',
+	'onInput',
+	'onInputCapture',
+	'onReset',
+	'onResetCapture',
+	'onSubmit',
+	'onSubmitCapture',
+	'onInvalid',
+	'onInvalidCapture',
+	'onLoad',
+	'onLoadCapture',
+	'onError',
+	'onErrorCapture',
+	'onKeyDown',
+	'onKeyDownCapture',
+	'onKeyPress',
+	'onKeyPressCapture',
+	'onKeyUp',
+	'onKeyUpCapture',
+	'onAbort',
+	'onAbortCapture',
+	'onCanPlay',
+	'onCanPlayCapture',
+	'onCanPlayThrough',
+	'onCanPlayThroughCapture',
+	'onDurationChange',
+	'onDurationChangeCapture',
+	'onEmptied',
+	'onEmptiedCapture',
+	'onEncrypted',
+	'onEncryptedCapture',
+	'onEnded',
+	'onEndedCapture',
+	'onLoadedData',
+	'onLoadedDataCapture',
+	'onLoadedMetadata',
+	'onLoadedMetadataCapture',
+	'onLoadStart',
+	'onLoadStartCapture',
+	'onPause',
+	'onPauseCapture',
+	'onPlay',
+	'onPlayCapture',
+	'onPlaying',
+	'onPlayingCapture',
+	'onProgress',
+	'onProgressCapture',
+	'onRateChange',
+	'onRateChangeCapture',
+	'onSeeked',
+	'onSeekedCapture',
+	'onSeeking',
+	'onSeekingCapture',
+	'onStalled',
+	'onStalledCapture',
+	'onSuspend',
+	'onSuspendCapture',
+	'onTimeUpdate',
+	'onTimeUpdateCapture',
+	'onVolumeChange',
+	'onVolumeChangeCapture',
+	'onWaiting',
+	'onWaitingCapture',
+	'onAuxClick',
+	'onAuxClickCapture',
+	'onClick',
+	'onClickCapture',
+	'onContextMenu',
+	'onContextMenuCapture',
+	'onDoubleClick',
+	'onDoubleClickCapture',
+	'onDrag',
+	'onDragCapture',
+	'onDragEnd',
+	'onDragEndCapture',
+	'onDragEnter',
+	'onDragEnterCapture',
+	'onDragExit',
+	'onDragExitCapture',
+	'onDragLeave',
+	'onDragLeaveCapture',
+	'onDragOver',
+	'onDragOverCapture',
+	'onDragStart',
+	'onDragStartCapture',
+	'onDrop',
+	'onDropCapture',
+	'onMouseDown',
+	'onMouseDownCapture',
+	'onMouseEnter',
+	'onMouseLeave',
+	'onMouseMove',
+	'onMouseMoveCapture',
+	'onMouseOut',
+	'onMouseOutCapture',
+	'onMouseOver',
+	'onMouseOverCapture',
+	'onMouseUp',
+	'onMouseUpCapture',
+	'onSelect',
+	'onSelectCapture',
+	'onTouchCancel',
+	'onTouchCancelCapture',
+	'onTouchEnd',
+	'onTouchEndCapture',
+	'onTouchMove',
+	'onTouchMoveCapture',
+	'onTouchStart',
+	'onTouchStartCapture',
+	'onPointerDown',
+	'onPointerDownCapture',
+	'onPointerMove',
+	'onPointerMoveCapture',
+	'onPointerUp',
+	'onPointerUpCapture',
+	'onPointerCancel',
+	'onPointerCancelCapture',
+	'onPointerEnter',
+	'onPointerEnterCapture',
+	'onPointerLeave',
+	'onPointerLeaveCapture',
+	'onPointerOver',
+	'onPointerOverCapture',
+	'onPointerOut',
+	'onPointerOutCapture',
+	'onGotPointerCapture',
+	'onGotPointerCaptureCapture',
+	'onLostPointerCapture',
+	'onLostPointerCaptureCapture',
+	'onScroll',
+	'onScrollCapture',
+	'onWheel',
+	'onWheelCapture',
+	'onAnimationStart',
+	'onAnimationStartCapture',
+	'onAnimationEnd',
+	'onAnimationEndCapture',
+	'onAnimationIteration',
+	'onAnimationIterationCapture',
+	'onTransitionEnd',
+	'onTransitionEndCapture',
+];
+export function isEventKey(key) {
+	if (typeof key !== 'string') {
+		return false;
+	}
+	var allowedEventKeys = EventKeys;
+	return allowedEventKeys.includes(key);
+}