react-intl 8.0.10 → 8.1.0

package/src/components/plural.js

@@ -1,18 +1,25 @@
+/*
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import * as React from "react";
+import "@formatjs/intl";
+import useIntl from "./useIntl.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-import useIntl from './useIntl.js';
-var FormattedPlural = function (props) {
-    var _a = useIntl(), formatPlural = _a.formatPlural, Text = _a.textComponent;
-    var value = props.value, other = props.other, children = props.children;
-    var pluralCategory = formatPlural(value, props);
-    var formattedPlural = props[pluralCategory] || other;
-    if (typeof children === 'function') {
-        return children(formattedPlural);
-    }
-    if (Text) {
-        return _jsx(Text, { children: formattedPlural });
-    }
-    // Work around @types/react where React.FC cannot return string
-    return formattedPlural;
+const FormattedPlural = (props) => {
+	const { formatPlural, textComponent: Text } = useIntl();
+	const { value, other, children } = props;
+	const pluralCategory = formatPlural(value, props);
+	const formattedPlural = props[pluralCategory] || other;
+	if (typeof children === "function") {
+		return children(formattedPlural);
+	}
+	if (Text) {
+		return /* @__PURE__ */ _jsx(Text, { children: formattedPlural });
+	}
+	// Work around @types/react where React.FC cannot return string
+	return formattedPlural;
 };
-FormattedPlural.displayName = 'FormattedPlural';
+FormattedPlural.displayName = "FormattedPlural";
 export default FormattedPlural;

package/src/components/provider.d.ts

@@ -1,29 +1,28 @@
-import { IntlCache } from '@formatjs/intl';
-import * as React from 'react';
-import type { IntlConfig, IntlShape } from '../types.js';
-import { DefaultIntlConfig } from '../utils.js';
+import { type IntlCache } from "@formatjs/intl";
+import * as React from "react";
+import type { IntlConfig, IntlShape } from "../types.js";
+import { type DefaultIntlConfig } from "../utils.js";
 interface State {
-    /**
-     * Explicit intl cache to prevent memory leaks
-     */
-    cache: IntlCache;
-    /**
-     * Intl object we created
-     */
-    intl?: IntlShape;
-    /**
-     * list of memoized config we care about.
-     * This is important since creating intl is
-     * very expensive
-     */
-    prevConfig: IntlConfig;
+	/**
+	* Explicit intl cache to prevent memory leaks
+	*/
+	cache: IntlCache;
+	/**
+	* Intl object we created
+	*/
+	intl?: IntlShape;
+	/**
+	* list of memoized config we care about.
+	* This is important since creating intl is
+	* very expensive
+	*/
+	prevConfig: IntlConfig;
 }
 export default class IntlProvider extends React.PureComponent<React.PropsWithChildren<IntlConfig>, State> {
-    static displayName: string;
-    static defaultProps: DefaultIntlConfig;
-    private cache;
-    state: State;
-    static getDerivedStateFromProps(props: Readonly<IntlConfig>, { prevConfig, cache }: State): Partial<State> | null;
-    render(): React.JSX.Element;
+	static displayName: string;
+	static defaultProps: DefaultIntlConfig;
+	private cache;
+	state: State;
+	static getDerivedStateFromProps(props: Readonly<IntlConfig>, { prevConfig, cache }: State): Partial<State> | null;
+	render(): React.JSX.Element;
 }
-export {};

package/src/components/provider.js

@@ -1,60 +1,54 @@
-import { __extends } from "tslib";
-import { jsx as _jsx } from "react/jsx-runtime";
 /*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import { createIntlCache } from '@formatjs/intl';
-import * as React from 'react';
-import { DEFAULT_INTL_CONFIG, invariantIntlContext, shallowEqual, } from '../utils.js';
-import { createIntl } from './createIntl.js';
-import { Provider } from './injectIntl.js';
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import { createIntlCache } from "@formatjs/intl";
+import * as React from "react";
+import { DEFAULT_INTL_CONFIG, invariantIntlContext, shallowEqual } from "../utils.js";
+import { createIntl } from "./createIntl.js";
+import { Provider } from "./injectIntl.js";
+import { jsx as _jsx } from "react/jsx-runtime";
 function processIntlConfig(config) {
-    return {
-        locale: config.locale,
-        timeZone: config.timeZone,
-        fallbackOnEmptyString: config.fallbackOnEmptyString,
-        formats: config.formats,
-        textComponent: config.textComponent,
-        messages: config.messages,
-        defaultLocale: config.defaultLocale,
-        defaultFormats: config.defaultFormats,
-        onError: config.onError,
-        onWarn: config.onWarn,
-        wrapRichTextChunksInFragment: config.wrapRichTextChunksInFragment,
-        defaultRichTextElements: config.defaultRichTextElements,
-    };
+	return {
+		locale: config.locale,
+		timeZone: config.timeZone,
+		fallbackOnEmptyString: config.fallbackOnEmptyString,
+		formats: config.formats,
+		textComponent: config.textComponent,
+		messages: config.messages,
+		defaultLocale: config.defaultLocale,
+		defaultFormats: config.defaultFormats,
+		onError: config.onError,
+		onWarn: config.onWarn,
+		wrapRichTextChunksInFragment: config.wrapRichTextChunksInFragment,
+		defaultRichTextElements: config.defaultRichTextElements
+	};
+}
+export default class IntlProvider extends React.PureComponent {
+	static displayName = "IntlProvider";
+	static defaultProps = DEFAULT_INTL_CONFIG;
+	cache = createIntlCache();
+	state = {
+		cache: this.cache,
+		intl: createIntl(processIntlConfig(this.props), this.cache),
+		prevConfig: processIntlConfig(this.props)
+	};
+	static getDerivedStateFromProps(props, { prevConfig, cache }) {
+		const config = processIntlConfig(props);
+		if (!shallowEqual(prevConfig, config)) {
+			return {
+				intl: createIntl(config, cache),
+				prevConfig: config
+			};
+		}
+		return null;
+	}
+	render() {
+		invariantIntlContext(this.state.intl);
+		return /* @__PURE__ */ _jsx(Provider, {
+			value: this.state.intl,
+			children: this.props.children
+		});
+	}
 }
-var IntlProvider = /** @class */ (function (_super) {
-    __extends(IntlProvider, _super);
-    function IntlProvider() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.cache = createIntlCache();
-        _this.state = {
-            cache: _this.cache,
-            intl: createIntl(processIntlConfig(_this.props), _this.cache),
-            prevConfig: processIntlConfig(_this.props),
-        };
-        return _this;
-    }
-    IntlProvider.getDerivedStateFromProps = function (props, _a) {
-        var prevConfig = _a.prevConfig, cache = _a.cache;
-        var config = processIntlConfig(props);
-        if (!shallowEqual(prevConfig, config)) {
-            return {
-                intl: createIntl(config, cache),
-                prevConfig: config,
-            };
-        }
-        return null;
-    };
-    IntlProvider.prototype.render = function () {
-        invariantIntlContext(this.state.intl);
-        return _jsx(Provider, { value: this.state.intl, children: this.props.children });
-    };
-    IntlProvider.displayName = 'IntlProvider';
-    IntlProvider.defaultProps = DEFAULT_INTL_CONFIG;
-    return IntlProvider;
-}(React.PureComponent));
-export default IntlProvider;

package/src/components/relative.d.ts

@@ -1,10 +1,10 @@
-import * as React from 'react';
-import { FormatRelativeTimeOptions } from '@formatjs/intl';
+import * as React from "react";
+import { type FormatRelativeTimeOptions } from "@formatjs/intl";
 export interface Props extends FormatRelativeTimeOptions {
-    value?: number;
-    unit?: Intl.RelativeTimeFormatUnit;
-    updateIntervalInSeconds?: number;
-    children?(value: string): React.ReactElement | null;
+	value?: number;
+	unit?: Intl.RelativeTimeFormatUnit;
+	updateIntervalInSeconds?: number;
+	children?(value: string): React.ReactElement | null;
 }
 declare const FormattedRelativeTime: React.FC<Props>;
 export default FormattedRelativeTime;

package/src/components/relative.js

@@ -1,126 +1,120 @@
-import { __assign, __rest } from "tslib";
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 /*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import * as React from 'react';
-import { invariant } from '../utils.js';
-import useIntl from './useIntl.js';
-var MINUTE = 60;
-var HOUR = 60 * 60;
-var DAY = 60 * 60 * 24;
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import * as React from "react";
+import "@formatjs/intl";
+import { invariant } from "../utils.js";
+import useIntl from "./useIntl.js";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+const MINUTE = 60;
+const HOUR = 60 * 60;
+const DAY = 60 * 60 * 24;
 function selectUnit(seconds) {
-    var absValue = Math.abs(seconds);
-    if (absValue < MINUTE) {
-        return 'second';
-    }
-    if (absValue < HOUR) {
-        return 'minute';
-    }
-    if (absValue < DAY) {
-        return 'hour';
-    }
-    return 'day';
+	const absValue = Math.abs(seconds);
+	if (absValue < MINUTE) {
+		return "second";
+	}
+	if (absValue < HOUR) {
+		return "minute";
+	}
+	if (absValue < DAY) {
+		return "hour";
+	}
+	return "day";
 }
 function getDurationInSeconds(unit) {
-    switch (unit) {
-        case 'second':
-            return 1;
-        case 'minute':
-            return MINUTE;
-        case 'hour':
-            return HOUR;
-        default:
-            return DAY;
-    }
+	switch (unit) {
+		case "second": return 1;
+		case "minute": return MINUTE;
+		case "hour": return HOUR;
+		default: return DAY;
+	}
 }
 function valueToSeconds(value, unit) {
-    if (!value) {
-        return 0;
-    }
-    switch (unit) {
-        case 'second':
-            return value;
-        case 'minute':
-            return value * MINUTE;
-        default:
-            return value * HOUR;
-    }
+	if (!value) {
+		return 0;
+	}
+	switch (unit) {
+		case "second": return value;
+		case "minute": return value * MINUTE;
+		default: return value * HOUR;
+	}
 }
-var INCREMENTABLE_UNITS = [
-    'second',
-    'minute',
-    'hour',
+const INCREMENTABLE_UNITS = [
+	"second",
+	"minute",
+	"hour"
 ];
-function canIncrement(unit) {
-    if (unit === void 0) { unit = 'second'; }
-    return INCREMENTABLE_UNITS.indexOf(unit) > -1;
+function canIncrement(unit = "second") {
+	return INCREMENTABLE_UNITS.indexOf(unit) > -1;
 }
-var SimpleFormattedRelativeTime = function (props) {
-    var _a = useIntl(), formatRelativeTime = _a.formatRelativeTime, Text = _a.textComponent;
-    var children = props.children, value = props.value, unit = props.unit, otherProps = __rest(props, ["children", "value", "unit"]);
-    var formattedRelativeTime = formatRelativeTime(value || 0, unit, otherProps);
-    if (typeof children === 'function') {
-        return children(formattedRelativeTime);
-    }
-    if (Text) {
-        return _jsx(Text, { children: formattedRelativeTime });
-    }
-    return _jsx(_Fragment, { children: formattedRelativeTime });
+const SimpleFormattedRelativeTime = (props) => {
+	const { formatRelativeTime, textComponent: Text } = useIntl();
+	const { children, value, unit, ...otherProps } = props;
+	const formattedRelativeTime = formatRelativeTime(value || 0, unit, otherProps);
+	if (typeof children === "function") {
+		return children(formattedRelativeTime);
+	}
+	if (Text) {
+		return /* @__PURE__ */ _jsx(Text, { children: formattedRelativeTime });
+	}
+	return /* @__PURE__ */ _jsx(_Fragment, { children: formattedRelativeTime });
 };
-var FormattedRelativeTime = function (_a) {
-    var _b = _a.value, value = _b === void 0 ? 0 : _b, _c = _a.unit, unit = _c === void 0 ? 'second' : _c, updateIntervalInSeconds = _a.updateIntervalInSeconds, otherProps = __rest(_a, ["value", "unit", "updateIntervalInSeconds"]);
-    invariant(!updateIntervalInSeconds ||
-        !!(updateIntervalInSeconds && canIncrement(unit)), 'Cannot schedule update with unit longer than hour');
-    var _d = React.useState(), prevUnit = _d[0], setPrevUnit = _d[1];
-    var _e = React.useState(0), prevValue = _e[0], setPrevValue = _e[1];
-    var _f = React.useState(0), currentValueInSeconds = _f[0], setCurrentValueInSeconds = _f[1];
-    var updateTimer;
-    if (unit !== prevUnit || value !== prevValue) {
-        setPrevValue(value || 0);
-        setPrevUnit(unit);
-        setCurrentValueInSeconds(canIncrement(unit) ? valueToSeconds(value, unit) : 0);
-    }
-    React.useEffect(function () {
-        function clearUpdateTimer() {
-            clearTimeout(updateTimer);
-        }
-        clearUpdateTimer();
-        // If there's no interval and we cannot increment this unit, do nothing
-        if (!updateIntervalInSeconds || !canIncrement(unit)) {
-            return clearUpdateTimer;
-        }
-        // Figure out the next interesting time
-        var nextValueInSeconds = currentValueInSeconds - updateIntervalInSeconds;
-        var nextUnit = selectUnit(nextValueInSeconds);
-        // We've reached the max auto incrementable unit, don't schedule another update
-        if (nextUnit === 'day') {
-            return clearUpdateTimer;
-        }
-        var unitDuration = getDurationInSeconds(nextUnit);
-        var remainder = nextValueInSeconds % unitDuration;
-        var prevInterestingValueInSeconds = nextValueInSeconds - remainder;
-        var nextInterestingValueInSeconds = prevInterestingValueInSeconds >= currentValueInSeconds
-            ? prevInterestingValueInSeconds - unitDuration
-            : prevInterestingValueInSeconds;
-        var delayInSeconds = Math.abs(nextInterestingValueInSeconds - currentValueInSeconds);
-        if (currentValueInSeconds !== nextInterestingValueInSeconds) {
-            updateTimer = setTimeout(function () { return setCurrentValueInSeconds(nextInterestingValueInSeconds); }, delayInSeconds * 1e3);
-        }
-        return clearUpdateTimer;
-    }, [currentValueInSeconds, updateIntervalInSeconds, unit]);
-    var currentValue = value || 0;
-    var currentUnit = unit;
-    if (canIncrement(unit) &&
-        typeof currentValueInSeconds === 'number' &&
-        updateIntervalInSeconds) {
-        currentUnit = selectUnit(currentValueInSeconds);
-        var unitDuration = getDurationInSeconds(currentUnit);
-        currentValue = Math.round(currentValueInSeconds / unitDuration);
-    }
-    return (_jsx(SimpleFormattedRelativeTime, __assign({ value: currentValue, unit: currentUnit }, otherProps)));
+const FormattedRelativeTime = ({ value = 0, unit = "second", updateIntervalInSeconds, ...otherProps }) => {
+	invariant(!updateIntervalInSeconds || !!(updateIntervalInSeconds && canIncrement(unit)), "Cannot schedule update with unit longer than hour");
+	const [prevUnit, setPrevUnit] = React.useState();
+	const [prevValue, setPrevValue] = React.useState(0);
+	const [currentValueInSeconds, setCurrentValueInSeconds] = React.useState(0);
+	const updateTimer = React.useRef(undefined);
+	if (unit !== prevUnit || value !== prevValue) {
+		setPrevValue(value || 0);
+		setPrevUnit(unit);
+		setCurrentValueInSeconds(canIncrement(unit) ? valueToSeconds(value, unit) : 0);
+	}
+	React.useEffect(() => {
+		function clearUpdateTimer() {
+			clearTimeout(updateTimer.current);
+		}
+		clearUpdateTimer();
+		// If there's no interval and we cannot increment this unit, do nothing
+		if (!updateIntervalInSeconds || !canIncrement(unit)) {
+			return clearUpdateTimer;
+		}
+		// Figure out the next interesting time
+		const nextValueInSeconds = currentValueInSeconds - updateIntervalInSeconds;
+		const nextUnit = selectUnit(nextValueInSeconds);
+		// We've reached the max auto incrementable unit, don't schedule another update
+		if (nextUnit === "day") {
+			return clearUpdateTimer;
+		}
+		const unitDuration = getDurationInSeconds(nextUnit);
+		const remainder = nextValueInSeconds % unitDuration;
+		const prevInterestingValueInSeconds = nextValueInSeconds - remainder;
+		const nextInterestingValueInSeconds = prevInterestingValueInSeconds >= currentValueInSeconds ? prevInterestingValueInSeconds - unitDuration : prevInterestingValueInSeconds;
+		const delayInSeconds = Math.abs(nextInterestingValueInSeconds - currentValueInSeconds);
+		if (currentValueInSeconds !== nextInterestingValueInSeconds) {
+			updateTimer.current = setTimeout(() => setCurrentValueInSeconds(nextInterestingValueInSeconds), delayInSeconds * 1e3);
+		}
+		return clearUpdateTimer;
+	}, [
+		currentValueInSeconds,
+		updateIntervalInSeconds,
+		unit
+	]);
+	let currentValue = value || 0;
+	let currentUnit = unit;
+	if (canIncrement(unit) && typeof currentValueInSeconds === "number" && updateIntervalInSeconds) {
+		currentUnit = selectUnit(currentValueInSeconds);
+		const unitDuration = getDurationInSeconds(currentUnit);
+		currentValue = Math.round(currentValueInSeconds / unitDuration);
+	}
+	return /* @__PURE__ */ _jsx(SimpleFormattedRelativeTime, {
+		value: currentValue,
+		unit: currentUnit,
+		...otherProps
+	});
 };
-FormattedRelativeTime.displayName = 'FormattedRelativeTime';
+FormattedRelativeTime.displayName = "FormattedRelativeTime";
 export default FormattedRelativeTime;

package/src/components/useIntl.d.ts

@@ -1,2 +1,2 @@
-import { IntlShape } from '../types.js';
+import { type IntlShape } from "../types.js";
 export default function useIntl(this: void): IntlShape;

package/src/components/useIntl.js

@@ -1,8 +1,9 @@
-import * as React from 'react';
-import { invariantIntlContext } from '../utils.js';
-import { Context } from './injectIntl.js';
+import * as React from "react";
+import "../types.js";
+import { invariantIntlContext } from "../utils.js";
+import { Context } from "./injectIntl.js";
 export default function useIntl() {
-    var intl = React.useContext(Context);
-    invariantIntlContext(intl);
-    return intl;
+	const intl = React.useContext(Context);
+	invariantIntlContext(intl);
+	return intl;
 }

package/src/types.d.ts

@@ -1,14 +1,14 @@
-import { ResolvedIntlConfig as CoreResolvedIntlConfig, Formatters, IntlFormatters, MessageDescriptor } from '@formatjs/intl';
-import { FormatXMLElementFn, Options as IntlMessageFormatOptions, PrimitiveType } from 'intl-messageformat';
-import * as React from 'react';
-import { DEFAULT_INTL_CONFIG } from './utils.js';
+import { type ResolvedIntlConfig as CoreResolvedIntlConfig, type Formatters, type IntlFormatters, type MessageDescriptor } from "@formatjs/intl";
+import { type FormatXMLElementFn, type Options as IntlMessageFormatOptions, type PrimitiveType } from "intl-messageformat";
+import * as React from "react";
+import type { DEFAULT_INTL_CONFIG } from "./utils.js";
 export type IntlConfig = Omit<ResolvedIntlConfig, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
 export interface ResolvedIntlConfig extends CoreResolvedIntlConfig<React.ReactNode> {
-    textComponent?: React.ComponentType | keyof React.JSX.IntrinsicElements;
-    wrapRichTextChunksInFragment?: boolean;
+	textComponent?: React.ComponentType | keyof React.JSX.IntrinsicElements;
+	wrapRichTextChunksInFragment?: boolean;
 }
 export interface IntlShape extends ResolvedIntlConfig, IntlFormatters<React.ReactNode> {
-    formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
-    formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, React.ReactNode | PrimitiveType | FormatXMLElementFn<string, React.ReactNode>>, opts?: IntlMessageFormatOptions): Array<React.ReactNode>;
-    formatters: Formatters;
+	formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
+	formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, React.ReactNode | PrimitiveType | FormatXMLElementFn<string, React.ReactNode>>, opts?: IntlMessageFormatOptions): Array<React.ReactNode>;
+	formatters: Formatters;
 }

package/src/types.js

@@ -1 +1,8 @@
-export {};
+/*
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import "@formatjs/intl";
+import "intl-messageformat";
+import * as React from "react";

package/src/utils.d.ts

@@ -1,26 +1,26 @@
-import { FormatXMLElementFn } from 'intl-messageformat';
-import * as React from 'react';
-import { ResolvedIntlConfig } from './types.js';
+import { type FormatXMLElementFn } from "intl-messageformat";
+import * as React from "react";
+import { type ResolvedIntlConfig } from "./types.js";
 export declare function invariant(condition: boolean, message: string, Err?: any): asserts condition;
 export declare function invariantIntlContext(intl?: any): asserts intl;
-export type DefaultIntlConfig = Pick<ResolvedIntlConfig, 'fallbackOnEmptyString' | 'formats' | 'messages' | 'timeZone' | 'textComponent' | 'defaultLocale' | 'defaultFormats' | 'onError'>;
+export type DefaultIntlConfig = Pick<ResolvedIntlConfig, "fallbackOnEmptyString" | "formats" | "messages" | "timeZone" | "textComponent" | "defaultLocale" | "defaultFormats" | "onError">;
 export declare const DEFAULT_INTL_CONFIG: DefaultIntlConfig;
 /**
- * Builds an array of {@link React.ReactNode}s with index-based keys, similar to
- * {@link React.Children.toArray}. However, this function tells React that it
- * was intentional, so they won't produce a bunch of warnings about it.
- *
- * React doesn't recommend doing this because it makes reordering inefficient,
- * but we mostly need this for message chunks, which don't tend to reorder to
- * begin with.
- *
- */
+* Builds an array of {@link React.ReactNode}s with index-based keys, similar to
+* {@link React.Children.toArray}. However, this function tells React that it
+* was intentional, so they won't produce a bunch of warnings about it.
+*
+* React doesn't recommend doing this because it makes reordering inefficient,
+* but we mostly need this for message chunks, which don't tend to reorder to
+* begin with.
+*
+*/
 export declare const toKeyedReactNodeArray: typeof React.Children.toArray;
 /**
- * Takes a `formatXMLElementFn`, and composes it in function, which passes
- * argument `parts` through, assigning unique key to each part, to prevent
- * "Each child in a list should have a unique "key"" React error.
- * @param formatXMLElementFn
- */
+* Takes a `formatXMLElementFn`, and composes it in function, which passes
+* argument `parts` through, assigning unique key to each part, to prevent
+* "Each child in a list should have a unique "key"" React error.
+* @param formatXMLElementFn
+*/
 export declare function assignUniqueKeysToParts(formatXMLElementFn: FormatXMLElementFn<React.ReactNode>): FormatXMLElementFn<React.ReactNode>;
 export declare function shallowEqual<T extends Record<string, unknown> = Record<string, unknown>>(objA?: T, objB?: T): boolean;