@carbon/ibm-products 2.71.1 → 2.72.0-rc.0

package/es/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js

@@ -0,0 +1,95 @@
+/**
+ * Copyright IBM Corp. 2020, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { offset as offset$1, flip as flip$1, shift as shift$1, arrow as arrow$2 } from '../../dom/dist/floating-ui.dom.js';
+export { autoUpdate, computePosition, platform } from '../../dom/dist/floating-ui.dom.js';
+import 'react';
+import 'react-dom';
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow$1 = options => {
+  function isRef(value) {
+    return {}.hasOwnProperty.call(value, 'current');
+  }
+  return {
+    name: 'arrow',
+    options,
+    fn(state) {
+      const {
+        element,
+        padding
+      } = typeof options === 'function' ? options(state) : options;
+      if (element && isRef(element)) {
+        if (element.current != null) {
+          return arrow$2({
+            element: element.current,
+            padding
+          }).fn(state);
+        }
+        return {};
+      }
+      if (element) {
+        return arrow$2({
+          element,
+          padding
+        }).fn(state);
+      }
+      return {};
+    }
+  };
+};
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset = (options, deps) => ({
+  ...offset$1(options),
+  options: [options, deps]
+});
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = (options, deps) => ({
+  ...shift$1(options),
+  options: [options, deps]
+});
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = (options, deps) => ({
+  ...flip$1(options),
+  options: [options, deps]
+});
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = (options, deps) => ({
+  ...arrow$1(options),
+  options: [options, deps]
+});
+
+export { arrow, flip, offset, shift };

package/es/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,161 @@
+/**
+ * Copyright IBM Corp. 2020, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+function hasWindow() {
+  return typeof window !== 'undefined';
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || '').toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+  return '#document';
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
+}
+function isTableElement(element) {
+  return ['table', 'td', 'th'].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [':popover-open', ':modal'].some(selector => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
+  return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === 'undefined' || !CSS.supports) return false;
+  return CSS.supports('-webkit-backdrop-filter', 'none');
+}
+function isLastTraversableNode(node) {
+  return ['html', 'body', '#document'].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === 'html') {
+    return node;
+  }
+  const result =
+  // Step into the shadow DOM of the parent of a slotted node.
+  node.assignedSlot ||
+  // DOM Element detected.
+  node.parentNode ||
+  // ShadowRoot detected.
+  isShadowRoot(node) && node.host ||
+  // Fallback.
+  getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
+export { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };

package/es/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

@@ -0,0 +1,142 @@
+/**
+ * Copyright IBM Corp. 2020, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+const oppositeAlignmentMap = {
+  start: 'end',
+  end: 'start'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+function getSideAxis(placement) {
+  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(side => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+
+export { clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, rectToClientRect, round };

package/es/settings.d.ts

@@ -67,8 +67,9 @@ export const pkg: {
         Nav: boolean;
         NavItem: boolean;
         NavList: boolean;
-        BigNumbers: boolean;
+        BigNumber: boolean;
         TruncatedList: boolean;
+        TruncatedText: boolean;
         DelimitedList: boolean;
         ScrollGradient: boolean;
         StringFormatter: boolean;

package/lib/components/{BigNumbers/BigNumbers.d.ts → BigNumber/BigNumber.d.ts}

@@ -5,8 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 import React, { ReactNode } from 'react';
-import { BigNumbersSizeValues } from './constants';
-export interface BigNumbersProps {
+import { BigNumberSizeValues } from './constants';
+export interface BigNumberProps {
     className?: string;
     forceShowTotal?: boolean;
     fractionDigits?: number;
@@ -15,7 +15,7 @@ export interface BigNumbersProps {
     label: string;
     locale?: string;
     percentage?: boolean;
-    size?: BigNumbersSizeValues;
+    size?: BigNumberSizeValues;
     tooltipDescription?: string;
     total?: number;
     trending?: boolean;
@@ -23,7 +23,7 @@ export interface BigNumbersProps {
     value?: number;
 }
 /**
- * BigNumbers is used to display large values in a small area. The display of
+ * BigNumber is used to display large values in a small area. The display of
  * values can be the value itself, or grouped in a `numerator/denominator` fashion.
  * Control over the total fraction decimals displayed as well as how the
  * values/totals are displayed are done via a locale prop. Other optional props
@@ -31,4 +31,4 @@ export interface BigNumbersProps {
  * of a button as well as tool tip functionality.
  * The default locale is English (`en-US`) if one is not provided or if the provided one is not supported.
  */
-export declare let BigNumbers: React.ForwardRefExoticComponent<BigNumbersProps & React.RefAttributes<HTMLDivElement>>;
+export declare let BigNumber: React.ForwardRefExoticComponent<BigNumberProps & React.RefAttributes<HTMLDivElement>>;

package/lib/components/{BigNumbers/BigNumbers.js → BigNumber/BigNumber.js}

@@ -16,18 +16,18 @@ var getSupportedLocale = require('../../global/js/utils/getSupportedLocale.js');
 var settings = require('../../settings.js');
 var icons = require('@carbon/react/icons');
 var react = require('@carbon/react');
-var BigNumbersSkeleton = require('./BigNumbersSkeleton.js');
+var BigNumberSkeleton = require('./BigNumberSkeleton.js');
 var constants = require('./constants.js');
 var TooltipTrigger = require('../TooltipTrigger/TooltipTrigger.js');
 
 var _Information;
-const blockClass = `${settings.pkg.prefix}--big-numbers`;
-const componentName = 'BigNumbers';
+const blockClass = `${settings.pkg.prefix}--big-number`;
+const componentName = 'BigNumber';
 
 // NOTE: the component SCSS is not imported here: it is rolled up separately.
 
 /**
- * BigNumbers is used to display large values in a small area. The display of
+ * BigNumber is used to display large values in a small area. The display of
  * values can be the value itself, or grouped in a `numerator/denominator` fashion.
  * Control over the total fraction decimals displayed as well as how the
  * values/totals are displayed are done via a locale prop. Other optional props
@@ -35,7 +35,7 @@ const componentName = 'BigNumbers';
  * of a button as well as tool tip functionality.
  * The default locale is English (`en-US`) if one is not provided or if the provided one is not supported.
  */
-exports.BigNumbers = /*#__PURE__*/React.forwardRef((_ref, ref) => {
+exports.BigNumber = /*#__PURE__*/React.forwardRef((_ref, ref) => {
   let {
     // The component props, in alphabetical order (for consistency).
     className,
@@ -55,7 +55,7 @@ exports.BigNumbers = /*#__PURE__*/React.forwardRef((_ref, ref) => {
     // Collect any other property values passed in.
     ...rest
   } = _ref;
-  const bigNumbersClasses = cx(className, {
+  const bigNumberClasses = cx(className, {
     [`${blockClass}--lg`]: size === 'lg',
     [`${blockClass}--xl`]: size === 'xl'
   });
@@ -64,14 +64,14 @@ exports.BigNumbers = /*#__PURE__*/React.forwardRef((_ref, ref) => {
   const truncatedTotal = constants.formatValue(supportedLocale, total, fractionDigits, truncate) ?? 'Unknown';
   const shouldDisplayDenominator = forceShowTotal || !percentage && total && value && total > value && truncatedValue !== truncatedTotal;
   if (loading) {
-    return /*#__PURE__*/React.createElement(BigNumbersSkeleton.BigNumbersSkeleton, _rollupPluginBabelHelpers.extends({}, rest, {
+    return /*#__PURE__*/React.createElement(BigNumberSkeleton.BigNumberSkeleton, _rollupPluginBabelHelpers.extends({}, rest, {
       ref: ref,
       className: className,
       size: size
     }, devtools.getDevtoolsProps(componentName)));
   }
   return /*#__PURE__*/React.createElement("div", _rollupPluginBabelHelpers.extends({}, rest, {
-    className: cx(blockClass, bigNumbersClasses, className),
+    className: cx(blockClass, bigNumberClasses, className),
     ref: ref
   }, devtools.getDevtoolsProps(componentName)), /*#__PURE__*/React.createElement("span", {
     className: `${blockClass}__row`
@@ -105,16 +105,16 @@ exports.BigNumbers = /*#__PURE__*/React.forwardRef((_ref, ref) => {
 });
 
 // Return a placeholder if not released and not enabled by feature flag
-exports.BigNumbers = settings.pkg.checkComponentEnabled(exports.BigNumbers, componentName);
+exports.BigNumber = settings.pkg.checkComponentEnabled(exports.BigNumber, componentName);
 
 // The display name of the component, used by React. Note that displayName
 // is used in preference to relying on function.name.
-exports.BigNumbers.displayName = componentName;
+exports.BigNumber.displayName = componentName;
 
 // The types and DocGen commentary for the component props,
 // in alphabetical order (for consistency).
 // See https://www.npmjs.com/package/prop-types#usage.
-exports.BigNumbers.propTypes = {
+exports.BigNumber.propTypes = {
   /**
    * Provide an optional class to be applied to the containing node.
    */

package/lib/components/BigNumber/BigNumberSkeleton.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright IBM Corp. 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import React from 'react';
+import { BigNumberProps } from './BigNumber';
+/**
+ * SkeletonBigNumber is used to display a skeleton version while
+ * content is loading (handled by the BigNumber prop `loading').
+ *
+ * Note: This component is only used within BigNumber.
+ */
+type BigNumberSkeletonProps = Pick<BigNumberProps, 'className' | 'size'>;
+export declare const BigNumberSkeleton: React.ForwardRefExoticComponent<BigNumberSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/lib/components/{BigNumbers/BigNumbersSkeleton.js → BigNumber/BigNumberSkeleton.js}

@@ -17,30 +17,30 @@ var react = require('@carbon/react');
 var constants = require('./constants.js');
 
 // The block part of our conventional BEM class names (blockClass__E--M).
-const blockClass = `${settings.pkg.prefix}--big-numbers-skeleton`;
-const componentName = 'BigNumbersSkeleton';
+const blockClass = `${settings.pkg.prefix}--big-number-skeleton`;
+const componentName = 'BigNumberSkeleton';
 
 /**
- * SkeletonBigNumbers is used to display a skeleton version while
- * content is loading (handled by the BigNumbers prop `loading').
+ * SkeletonBigNumber is used to display a skeleton version while
+ * content is loading (handled by the BigNumber prop `loading').
  *
- * Note: This component is only used within BigNumbers.
+ * Note: This component is only used within BigNumber.
  */
 
-// Use the same properties and values as parent BigNumbersProps
+// Use the same properties and values as parent BigNumberProps
 
-const BigNumbersSkeleton = /*#__PURE__*/React.forwardRef((_ref, ref) => {
+const BigNumberSkeleton = /*#__PURE__*/React.forwardRef((_ref, ref) => {
   let {
     className,
     size,
     ...rest
   } = _ref;
-  const bigNumbersSkeletonClasses = cx(className, blockClass, {
-    [`${blockClass}--lg`]: size === constants.BigNumbersSize.Large,
-    [`${blockClass}--xl`]: size === constants.BigNumbersSize.XLarge
+  const bigNumberSkeletonClasses = cx(className, blockClass, {
+    [`${blockClass}--lg`]: size === constants.BigNumberSize.Large,
+    [`${blockClass}--xl`]: size === constants.BigNumberSize.XLarge
   });
   return /*#__PURE__*/React.createElement("div", _rollupPluginBabelHelpers.extends({}, rest, {
-    className: bigNumbersSkeletonClasses,
+    className: bigNumberSkeletonClasses,
     ref: ref
   }, devtools.getDevtoolsProps(componentName)), /*#__PURE__*/React.createElement(react.SkeletonText, {
     className: `${blockClass}__label`
@@ -53,8 +53,8 @@ const BigNumbersSkeleton = /*#__PURE__*/React.forwardRef((_ref, ref) => {
 
 // The display name of the component, used by React. Note that displayName
 // is used in preference to relying on function.name.
-BigNumbersSkeleton.displayName = componentName;
-BigNumbersSkeleton.propTypes = {
+BigNumberSkeleton.displayName = componentName;
+BigNumberSkeleton.propTypes = {
   /**
    * Provide an optional class to be applied to the containing node.
    */
@@ -62,7 +62,7 @@ BigNumbersSkeleton.propTypes = {
   /**
    *
    */
-  size: index.default.oneOf([constants.BigNumbersSize.Default, constants.BigNumbersSize.Large, constants.BigNumbersSize.XLarge])
+  size: index.default.oneOf([constants.BigNumberSize.Default, constants.BigNumberSize.Large, constants.BigNumberSize.XLarge])
 };
 
-exports.BigNumbersSkeleton = BigNumbersSkeleton;
+exports.BigNumberSkeleton = BigNumberSkeleton;

package/lib/components/{BigNumbers → BigNumber}/constants.d.ts

@@ -4,16 +4,16 @@
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export declare enum BigNumbersSize {
+export declare enum BigNumberSize {
     Default = "default",
     Large = "lg",
     XLarge = "xl"
 }
-export type BigNumbersSizeValues = `${BigNumbersSize}`;
+export type BigNumberSizeValues = `${BigNumberSize}`;
 export declare enum Characters {
     Dash = "\u2013",
     Slash = "/"
 }
 export declare const DefaultLocale = "en-US";
 export declare const formatValue: (locale: Intl.LocalesArgument, value: number | null | undefined, fractionDigits: number, truncate: boolean) => string | null | undefined;
-export declare const getIconSize: (size: BigNumbersSizeValues) => number;
+export declare const getIconSize: (size: BigNumberSizeValues) => number;

package/lib/components/{BigNumbers → BigNumber}/constants.js

@@ -7,11 +7,11 @@
 
 'use strict';
 
-let BigNumbersSize = /*#__PURE__*/function (BigNumbersSize) {
-  BigNumbersSize["Default"] = "default";
-  BigNumbersSize["Large"] = "lg";
-  BigNumbersSize["XLarge"] = "xl";
-  return BigNumbersSize;
+let BigNumberSize = /*#__PURE__*/function (BigNumberSize) {
+  BigNumberSize["Default"] = "default";
+  BigNumberSize["Large"] = "lg";
+  BigNumberSize["XLarge"] = "xl";
+  return BigNumberSize;
 }({});
 
 // = 'default' | 'lg' | 'xl'
@@ -43,7 +43,7 @@ const getIconSize = size => {
   }
 };
 
-exports.BigNumbersSize = BigNumbersSize;
+exports.BigNumberSize = BigNumberSize;
 exports.Characters = Characters;
 exports.DefaultLocale = DefaultLocale;
 exports.formatValue = formatValue;

package/lib/components/BigNumber/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright IBM Corp. 2024, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export { BigNumber } from './BigNumber';

package/lib/components/Coachmark/Coachmark.js

@@ -14,7 +14,7 @@ var enums = require('./utils/enums.js');
 var context = require('./utils/context.js');
 var CoachmarkOverlay = require('./CoachmarkOverlay.js');
 var index = require('../../_virtual/index.js');
-var reactDom = require('react-dom');
+var ReactDOM = require('react-dom');
 var cx = require('classnames');
 var devtools = require('../../global/js/utils/devtools.js');
 var settings = require('../../settings.js');
@@ -181,7 +181,7 @@ exports.Coachmark = /*#__PURE__*/React.forwardRef((_ref, ref) => {
     ref: _coachmarkRef
   }, rest, devtools.getDevtoolsProps(componentName)), overlayKind !== 'tooltip' ? /*#__PURE__*/React.createElement(React.Fragment, null, targetName?.displayName === 'CoachmarkBeacon' ? /*#__PURE__*/React.cloneElement(target, {
     buttonProps: contextValue.buttonProps
-  }) : target, isOpen && portalNode?.current && /*#__PURE__*/reactDom.createPortal(/*#__PURE__*/React.createElement(CoachmarkOverlay.CoachmarkOverlay, {
+  }) : target, isOpen && portalNode?.current && /*#__PURE__*/ReactDOM.createPortal(/*#__PURE__*/React.createElement(CoachmarkOverlay.CoachmarkOverlay, {
     ref: _overlayRef,
     fixedIsVisible: false,
     kind: overlayKind,