ag-charts-core/dist/package/main.cjs.js

Advanced Charting / Charts supporting Javascript / Typescript / React / Angular / Vue

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from3, except, desc) => {
  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
    for (let key of __getOwnPropNames(from3))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
  if (kind && result)
    __defProp(target, key, result);
  return result;
};

// packages/ag-charts-core/src/main.ts
var main_exports = {};
__export(main_exports, {
  AGGREGATION_INDEX_UNSET: () => AGGREGATION_INDEX_UNSET,
  AGGREGATION_INDEX_X_MAX: () => AGGREGATION_INDEX_X_MAX,
  AGGREGATION_INDEX_X_MIN: () => AGGREGATION_INDEX_X_MIN,
  AGGREGATION_INDEX_Y_MAX: () => AGGREGATION_INDEX_Y_MAX,
  AGGREGATION_INDEX_Y_MIN: () => AGGREGATION_INDEX_Y_MIN,
  AGGREGATION_MAX_POINTS: () => AGGREGATION_MAX_POINTS,
  AGGREGATION_MIN_RANGE: () => AGGREGATION_MIN_RANGE,
  AGGREGATION_SPAN: () => AGGREGATION_SPAN,
  AGGREGATION_THRESHOLD: () => AGGREGATION_THRESHOLD,
  AbstractModuleInstance: () => AbstractModuleInstance,
  ActionOnSet: () => ActionOnSet,
  AdjacencyListGraph: () => AdjacencyListGraph,
  AsyncAwaitQueue: () => AsyncAwaitQueue,
  BASE_FONT_SIZE: () => BASE_FONT_SIZE,
  BREAK_TRANSFORM_CHAIN: () => BREAK_TRANSFORM_CHAIN,
  BaseProperties: () => BaseProperties,
  Border: () => Border,
  CARTESIAN_AXIS_TYPE: () => CARTESIAN_AXIS_TYPE,
  CARTESIAN_POSITION: () => CARTESIAN_POSITION,
  CallbackCache: () => CallbackCache,
  ChangeDetectableProperties: () => ChangeDetectableProperties,
  ChartAxisDirection: () => ChartAxisDirection,
  ChartUpdateType: () => ChartUpdateType,
  CleanupRegistry: () => CleanupRegistry,
  Color: () => Color,
  DEFAULT_ANNOTATION_HANDLE_FILL: () => DEFAULT_ANNOTATION_HANDLE_FILL,
  DEFAULT_ANNOTATION_STATISTICS_COLOR: () => DEFAULT_ANNOTATION_STATISTICS_COLOR,
  DEFAULT_ANNOTATION_STATISTICS_DIVIDER_STROKE: () => DEFAULT_ANNOTATION_STATISTICS_DIVIDER_STROKE,
  DEFAULT_ANNOTATION_STATISTICS_DOWN_FILL: () => DEFAULT_ANNOTATION_STATISTICS_DOWN_FILL,
  DEFAULT_ANNOTATION_STATISTICS_DOWN_STROKE: () => DEFAULT_ANNOTATION_STATISTICS_DOWN_STROKE,
  DEFAULT_ANNOTATION_STATISTICS_FILL: () => DEFAULT_ANNOTATION_STATISTICS_FILL,
  DEFAULT_ANNOTATION_STATISTICS_STROKE: () => DEFAULT_ANNOTATION_STATISTICS_STROKE,
  DEFAULT_CAPTION_ALIGNMENT: () => DEFAULT_CAPTION_ALIGNMENT,
  DEFAULT_CAPTION_LAYOUT_STYLE: () => DEFAULT_CAPTION_LAYOUT_STYLE,
  DEFAULT_FIBONACCI_STROKES: () => DEFAULT_FIBONACCI_STROKES,
  DEFAULT_FINANCIAL_CHARTS_ANNOTATION_BACKGROUND_FILL: () => DEFAULT_FINANCIAL_CHARTS_ANNOTATION_BACKGROUND_FILL,
  DEFAULT_FINANCIAL_CHARTS_ANNOTATION_COLOR: () => DEFAULT_FINANCIAL_CHARTS_ANNOTATION_COLOR,
  DEFAULT_POLAR_SERIES_STROKE: () => DEFAULT_POLAR_SERIES_STROKE,
  DEFAULT_SHADOW_COLOUR: () => DEFAULT_SHADOW_COLOUR,
  DEFAULT_SPARKLINE_CROSSHAIR_STROKE: () => DEFAULT_SPARKLINE_CROSSHAIR_STROKE,
  DEFAULT_TEXTBOX_COLOR: () => DEFAULT_TEXTBOX_COLOR,
  DEFAULT_TEXTBOX_FILL: () => DEFAULT_TEXTBOX_FILL,
  DEFAULT_TEXTBOX_STROKE: () => DEFAULT_TEXTBOX_STROKE,
  DEFAULT_TEXT_ANNOTATION_COLOR: () => DEFAULT_TEXT_ANNOTATION_COLOR,
  DEFAULT_TOOLBAR_POSITION: () => DEFAULT_TOOLBAR_POSITION,
  Debug: () => debug_logger_exports,
  DebugMetrics: () => debug_metrics_exports,
  DeclaredSceneChangeDetection: () => DeclaredSceneChangeDetection,
  DeclaredSceneObjectChangeDetection: () => DeclaredSceneObjectChangeDetection,
  Deprecated: () => Deprecated,
  DeprecatedAndRenamedTo: () => DeprecatedAndRenamedTo,
  EllipsisChar: () => EllipsisChar,
  ErrorType: () => ErrorType,
  EventEmitter: () => EventEmitter,
  FONT_SIZE: () => FONT_SIZE,
  FONT_SIZE_RATIO: () => FONT_SIZE_RATIO,
  IS_DARK_THEME: () => IS_DARK_THEME,
  InterpolationProperties: () => InterpolationProperties,
  LRUCache: () => LRUCache,
  LineSplitter: () => LineSplitter,
  Logger: () => logger_exports,
  LonLatBBox: () => LonLatBBox,
  MementoCaretaker: () => MementoCaretaker,
  ModuleRegistry: () => moduleRegistry_exports,
  ModuleType: () => ModuleType,
  ObserveChanges: () => ObserveChanges,
  PALETTE_ALT_DOWN_FILL: () => PALETTE_ALT_DOWN_FILL,
  PALETTE_ALT_DOWN_STROKE: () => PALETTE_ALT_DOWN_STROKE,
  PALETTE_ALT_NEUTRAL_FILL: () => PALETTE_ALT_NEUTRAL_FILL,
  PALETTE_ALT_NEUTRAL_STROKE: () => PALETTE_ALT_NEUTRAL_STROKE,
  PALETTE_ALT_UP_FILL: () => PALETTE_ALT_UP_FILL,
  PALETTE_ALT_UP_STROKE: () => PALETTE_ALT_UP_STROKE,
  PALETTE_DOWN_FILL: () => PALETTE_DOWN_FILL,
  PALETTE_DOWN_STROKE: () => PALETTE_DOWN_STROKE,
  PALETTE_NEUTRAL_FILL: () => PALETTE_NEUTRAL_FILL,
  PALETTE_NEUTRAL_STROKE: () => PALETTE_NEUTRAL_STROKE,
  PALETTE_UP_FILL: () => PALETTE_UP_FILL,
  PALETTE_UP_STROKE: () => PALETTE_UP_STROKE,
  POLAR_AXIS_SHAPE: () => POLAR_AXIS_SHAPE,
  POLAR_AXIS_TYPE: () => POLAR_AXIS_TYPE,
  PREV_NEXT_KEYS: () => PREV_NEXT_KEYS,
  Padding: () => Padding,
  ParallelStateMachine: () => ParallelStateMachine,
  PolarZIndexMap: () => PolarZIndexMap,
  PropertiesArray: () => PropertiesArray,
  Property: () => addFakeTransformToInstanceProperty,
  ProxyOnWrite: () => ProxyOnWrite,
  ProxyProperty: () => ProxyProperty,
  ProxyPropertyOnWrite: () => ProxyPropertyOnWrite,
  SKIP_JS_BUILTINS: () => SKIP_JS_BUILTINS,
  ScaleAlignment: () => ScaleAlignment,
  SceneArrayChangeDetection: () => SceneArrayChangeDetection,
  SceneChangeDetection: () => SceneChangeDetection,
  SceneObjectChangeDetection: () => SceneObjectChangeDetection,
  SceneRefChangeDetection: () => SceneRefChangeDetection,
  SeriesContentZIndexMap: () => SeriesContentZIndexMap,
  SeriesZIndexMap: () => SeriesZIndexMap,
  SimpleCache: () => SimpleCache,
  SpanJoin: () => SpanJoin,
  StateMachine: () => StateMachine,
  StateMachineProperty: () => StateMachineProperty,
  TRIPLE_EQ: () => TRIPLE_EQ,
  TextMeasurer: () => TextMeasurer,
  TickIntervals: () => TickIntervals,
  ToolbarButtonProperties: () => ToolbarButtonProperties,
  TrimEdgeGuard: () => TrimEdgeGuard,
  UnknownError: () => UnknownError,
  ValidationError: () => ValidationError,
  Vec2: () => vector_exports,
  Vec4: () => vector4_exports,
  Vertex: () => Vertex,
  WeakCache: () => WeakCache,
  ZIndexMap: () => ZIndexMap,
  addEscapeEventListener: () => addEscapeEventListener,
  addFakeTransformToInstanceProperty: () => addFakeTransformToInstanceProperty,
  addMouseCloseListener: () => addMouseCloseListener,
  addObserverToInstanceProperty: () => addObserverToInstanceProperty,
  addOverrideFocusVisibleEventListener: () => addOverrideFocusVisibleEventListener,
  addTouchCloseListener: () => addTouchCloseListener,
  addTransformToInstanceProperty: () => addTransformToInstanceProperty,
  aggregationBucketForDatum: () => aggregationBucketForDatum,
  aggregationDatumMatchesIndex: () => aggregationDatumMatchesIndex,
  aggregationDomain: () => aggregationDomain,
  aggregationIndexForXRatio: () => aggregationIndexForXRatio,
  aggregationRangeFittingPoints: () => aggregationRangeFittingPoints,
  aggregationXRatioForDatumIndex: () => aggregationXRatioForDatumIndex,
  aggregationXRatioForXValue: () => aggregationXRatioForXValue,
  and: () => and,
  angleBetween: () => angleBetween,
  angularPadding: () => angularPadding,
  appendEllipsis: () => appendEllipsis,
  arcDistanceSquared: () => arcDistanceSquared,
  areScalingEqual: () => areScalingEqual,
  array: () => array,
  arrayLength: () => arrayLength,
  arrayOf: () => arrayOf,
  arrayOfDefs: () => arrayOfDefs,
  arraysEqual: () => arraysEqual,
  assignIfNotStrictlyEqual: () => assignIfNotStrictlyEqual,
  attachDescription: () => attachDescription,
  attachListener: () => attachListener,
  autoSizedLabelOptionsDefs: () => autoSizedLabelOptionsDefs,
  barHighlightOptionsDef: () => barHighlightOptionsDef,
  bezier2DDistance: () => bezier2DDistance,
  bezier2DExtrema: () => bezier2DExtrema,
  boolean: () => boolean,
  borderOptionsDef: () => borderOptionsDef,
  boxCollides: () => boxCollides,
  boxContains: () => boxContains,
  boxEmpty: () => boxEmpty,
  boxesEqual: () => boxesEqual,
  buildDateFormatter: () => buildDateFormatter,
  cachedTextMeasurer: () => cachedTextMeasurer,
  calcLineHeight: () => calcLineHeight,
  calculatePlacement: () => calculatePlacement,
  callWithContext: () => callWithContext,
  callback: () => callback,
  callbackDefs: () => callbackDefs,
  callbackOf: () => callbackOf,
  checkDatum: () => checkDatum,
  circularSliceArray: () => circularSliceArray,
  clamp: () => clamp,
  clampArray: () => clampArray,
  clipLines: () => clipLines,
  clipSpanX: () => clipSpanX,
  collapseSpanToPoint: () => collapseSpanToPoint,
  collectAggregationLevels: () => collectAggregationLevels,
  color: () => color,
  colorStopsOrderValidator: () => colorStopsOrderValidator,
  colorUnion: () => colorUnion,
  commonChartOptionsDefs: () => commonChartOptionsDefs,
  commonSeriesOptionsDefs: () => commonSeriesOptionsDefs,
  commonSeriesThemeableOptionsDefs: () => commonSeriesThemeableOptionsDefs,
  compactAggregationIndices: () => compactAggregationIndices,
  compareDates: () => compareDates,
  computeExtremesAggregation: () => computeExtremesAggregation,
  computeExtremesAggregationPartial: () => computeExtremesAggregationPartial,
  constant: () => constant,
  contextMenuItemsArray: () => contextMenuItemsArray,
  countFractionDigits: () => countFractionDigits,
  countLines: () => countLines,
  createAggregationIndices: () => createAggregationIndices,
  createButton: () => createButton,
  createCanvasContext: () => createCanvasContext,
  createCheckbox: () => createCheckbox,
  createDeprecationWarning: () => createDeprecationWarning,
  createElement: () => createElement,
  createElementId: () => createElementId,
  createIcon: () => createIcon,
  createId: () => createId,
  createIdsGenerator: () => createIdsGenerator,
  createNumberFormatter: () => createNumberFormatter,
  createSelect: () => createSelect,
  createSvgElement: () => createSvgElement,
  createTextArea: () => createTextArea,
  createTicks: () => createTicks,
  date: () => date,
  dateToNumber: () => dateToNumber,
  dateTruncationForDomain: () => dateTruncationForDomain,
  datesSortOrder: () => datesSortOrder,
  debounce: () => debounce,
  decodeIntervalValue: () => decodeIntervalValue,
  deepClone: () => deepClone,
  deepFreeze: () => deepFreeze,
  defaultEpoch: () => defaultEpoch,
  defined: () => defined,
  diffArrays: () => diffArrays,
  distribute: () => distribute,
  downloadUrl: () => downloadUrl,
  dropFirstWhile: () => dropFirstWhile,
  dropLastWhile: () => dropLastWhile,
  durationDay: () => durationDay,
  durationHour: () => durationHour,
  durationMinute: () => durationMinute,
  durationMonth: () => durationMonth,
  durationSecond: () => durationSecond,
  durationWeek: () => durationWeek,
  durationYear: () => durationYear,
  easeIn: () => easeIn,
  easeInOut: () => easeInOut,
  easeInOutQuad: () => easeInOutQuad,
  easeInQuad: () => easeInQuad,
  easeOut: () => easeOut,
  easeOutQuad: () => easeOutQuad,
  encodedToTimestamp: () => encodedToTimestamp,
  enterpriseRegistry: () => enterpriseRegistry,
  entries: () => entries,
  errorBarOptionsDefs: () => errorBarOptionsDefs,
  errorBarThemeableOptionsDefs: () => errorBarThemeableOptionsDefs,
  estimateTickCount: () => estimateTickCount,
  evaluateBezier: () => evaluateBezier,
  every: () => every,
  expandLegendPosition: () => expandLegendPosition,
  extent: () => extent,
  extractDecoratedProperties: () => extractDecoratedProperties,
  extractDomain: () => extractDomain,
  fillGradientDefaults: () => fillGradientDefaults,
  fillImageDefaults: () => fillImageDefaults,
  fillOptionsDef: () => fillOptionsDef,
  fillPatternDefaults: () => fillPatternDefaults,
  findMaxIndex: () => findMaxIndex,
  findMaxValue: () => findMaxValue,
  findMinIndex: () => findMinIndex,
  findMinMax: () => findMinMax,
  findMinValue: () => findMinValue,
  findRangeExtent: () => findRangeExtent,
  first: () => first,
  focusCursorAtEnd: () => focusCursorAtEnd,
  fontFamilyFull: () => fontFamilyFull,
  fontOptionsDef: () => fontOptionsDef,
  formatNumber: () => formatNumber,
  formatObjectValidator: () => formatObjectValidator,
  formatPercent: () => formatPercent,
  formatValue: () => formatValue,
  fromPairs: () => fromPairs,
  generateUUID: () => generateUUID,
  geoJson: () => geoJson,
  getAngleRatioRadians: () => getAngleRatioRadians,
  getAttribute: () => getAttribute,
  getDocument: () => getDocument,
  getElementBBox: () => getElementBBox,
  getIconClassNames: () => getIconClassNames,
  getLastFocus: () => getLastFocus,
  getMaxInnerRectSize: () => getMaxInnerRectSize,
  getMidpointsForIndices: () => getMidpointsForIndices,
  getMinOuterRectSize: () => getMinOuterRectSize,
  getPath: () => getPath,
  getTickTimeInterval: () => getTickTimeInterval,
  getWindow: () => getWindow,
  googleFont: () => googleFont,
  gradientColorStops: () => gradientColorStops,
  gradientStrict: () => gradientStrict,
  greaterThan: () => greaterThan,
  groupBy: () => groupBy,
  guardTextEdges: () => guardTextEdges,
  hasNoModifiers: () => hasNoModifiers,
  hasRequiredInPath: () => hasRequiredInPath,
  highlightOptionsDef: () => highlightOptionsDef,
  htmlElement: () => htmlElement,
  inRange: () => inRange,
  initRovingTabIndex: () => initRovingTabIndex,
  insertListItemsSorted: () => insertListItemsSorted,
  instanceOf: () => instanceOf,
  interpolationOptionsDefs: () => interpolationOptionsDefs,
  intervalCeil: () => intervalCeil,
  intervalEpoch: () => intervalEpoch,
  intervalExtent: () => intervalExtent,
  intervalFloor: () => intervalFloor,
  intervalHierarchy: () => intervalHierarchy,
  intervalMilliseconds: () => intervalMilliseconds,
  intervalNext: () => intervalNext,
  intervalPrevious: () => intervalPrevious,
  intervalRange: () => intervalRange,
  intervalRangeCount: () => intervalRangeCount,
  intervalRangeNumeric: () => intervalRangeNumeric,
  intervalRangeStartIndex: () => intervalRangeStartIndex,
  intervalStep: () => intervalStep,
  intervalUnit: () => intervalUnit,
  inverseEaseOut: () => inverseEaseOut,
  isArray: () => isArray,
  isBetweenAngles: () => isBetweenAngles,
  isBoolean: () => isBoolean,
  isButtonClickEvent: () => isButtonClickEvent,
  isColor: () => isColor,
  isContinuous: () => isContinuous,
  isDate: () => isDate,
  isDecoratedObject: () => isDecoratedObject,
  isDefined: () => isDefined,
  isDenseInterval: () => isDenseInterval,
  isEmptyObject: () => isEmptyObject,
  isEnumKey: () => isEnumKey,
  isEnumValue: () => isEnumValue,
  isFiniteNumber: () => isFiniteNumber,
  isFunction: () => isFunction,
  isGradientFill: () => isGradientFill,
  isGradientFillArray: () => isGradientFillArray,
  isGradientOrPatternFill: () => isGradientOrPatternFill,
  isHtmlElement: () => isHtmlElement,
  isImageFill: () => isImageFill,
  isInputPending: () => isInputPending,
  isInteger: () => isInteger,
  isKeyOf: () => isKeyOf,
  isNegative: () => isNegative,
  isNumber: () => isNumber,
  isNumberEqual: () => isNumberEqual,
  isNumberObject: () => isNumberObject,
  isObject: () => isObject,
  isObjectLike: () => isObjectLike,
  isObjectWithProperty: () => isObjectWithProperty,
  isObjectWithStringProperty: () => isObjectWithStringProperty,
  isPatternFill: () => isPatternFill,
  isPlainObject: () => isPlainObject,
  isPointLabelDatum: () => isPointLabelDatum,
  isProperties: () => isProperties,
  isRegExp: () => isRegExp,
  isScaleValid: () => isScaleValid,
  isSegmentTruncated: () => isSegmentTruncated,
  isString: () => isString,
  isStringFillArray: () => isStringFillArray,
  isStringObject: () => isStringObject,
  isSymbol: () => isSymbol,
  isTextTruncated: () => isTextTruncated,
  isTruncated: () => isTruncated,
  isUnitTimeCategoryScaling: () => isUnitTimeCategoryScaling,
  isValidDate: () => isValidDate,
  isValidNumberFormat: () => isValidNumberFormat,
  iterate: () => iterate,
  joinFormatted: () => joinFormatted,
  jsonApply: () => jsonApply,
  jsonDiff: () => jsonDiff,
  jsonPropertyCompare: () => jsonPropertyCompare,
  jsonWalk: () => jsonWalk,
  kebabCase: () => kebabCase,
  labelBoxOptionsDef: () => labelBoxOptionsDef,
  legendPositionValidator: () => legendPositionValidator,
  lessThan: () => lessThan,
  lessThanOrEqual: () => lessThanOrEqual,
  levenshteinDistance: () => levenshteinDistance,
  lineDashOptionsDef: () => lineDashOptionsDef,
  lineDistanceSquared: () => lineDistanceSquared,
  lineHighlightOptionsDef: () => lineHighlightOptionsDef,
  lineSegmentOptions: () => lineSegmentOptions,
  lineSegmentation: () => lineSegmentation,
  linear: () => linear,
  linearGaugeSeriesOptionsDef: () => linearGaugeSeriesOptionsDef,
  linearGaugeSeriesThemeableOptionsDef: () => linearGaugeSeriesThemeableOptionsDef,
  linearGaugeTargetOptionsDef: () => linearGaugeTargetOptionsDef,
  linearPoints: () => linearPoints,
  listDecoratedProperties: () => listDecoratedProperties,
  lowestGranularityForInterval: () => lowestGranularityForInterval,
  lowestGranularityUnitForTicks: () => lowestGranularityUnitForTicks,
  lowestGranularityUnitForValue: () => lowestGranularityUnitForValue,
  makeAccessibleClickListener: () => makeAccessibleClickListener,
  mapValues: () => mapValues,
  markerOptionsDefs: () => markerOptionsDefs,
  markerStyleOptionsDefs: () => markerStyleOptionsDefs,
  measureTextSegments: () => measureTextSegments,
  memo: () => memo,
  merge: () => merge,
  mergeArrayDefaults: () => mergeArrayDefaults,
  mergeDefaults: () => mergeDefaults,
  modulus: () => modulus,
  multiSeriesHighlightOptionsDef: () => multiSeriesHighlightOptionsDef,
  nearestSquared: () => nearestSquared,
  nearestSquaredInContainer: () => nearestSquaredInContainer,
  nextPowerOf2: () => nextPowerOf2,
  niceTicksDomain: () => niceTicksDomain,
  normalisedExtentWithMetadata: () => normalisedExtentWithMetadata,
  normalisedTimeExtentWithMetadata: () => normalisedTimeExtentWithMetadata,
  normalizeAngle180: () => normalizeAngle180,
  normalizeAngle360: () => normalizeAngle360,
  normalizeAngle360FromDegrees: () => normalizeAngle360FromDegrees,
  normalizeAngle360Inclusive: () => normalizeAngle360Inclusive,
  number: () => number,
  numberFormatValidator: () => numberFormatValidator,
  numberMin: () => numberMin,
  numberRange: () => numberRange,
  object: () => object,
  objectsEqual: () => objectsEqual,
  objectsEqualWith: () => objectsEqualWith,
  optionsDefs: () => optionsDefs,
  or: () => or,
  padding: () => padding,
  paddingOptions: () => paddingOptions,
  parseColor: () => parseColor,
  parseNumberFormat: () => parseNumberFormat,
  partialAssign: () => partialAssign,
  pause: () => pause,
  pick: () => pick,
  placeLabels: () => placeLabels,
  positiveNumber: () => positiveNumber,
  positiveNumberNonZero: () => positiveNumberNonZero,
  previousPowerOf2: () => previousPowerOf2,
  radialGaugeSeriesOptionsDef: () => radialGaugeSeriesOptionsDef,
  radialGaugeSeriesThemeableOptionsDef: () => radialGaugeSeriesThemeableOptionsDef,
  radialGaugeTargetOptionsDef: () => radialGaugeTargetOptionsDef,
  range: () => range,
  rangeValidator: () => rangeValidator,
  ratio: () => ratio,
  readIntegratedWrappedValue: () => readIntegratedWrappedValue,
  required: () => required,
  rescaleSpan: () => rescaleSpan,
  rescaleVisibleRange: () => rescaleVisibleRange,
  resetIds: () => resetIds,
  rotatePoint: () => rotatePoint,
  roundTo: () => roundTo,
  safeCall: () => safeCall,
  seriesLabelOptionsDefs: () => seriesLabelOptionsDefs,
  setAttribute: () => setAttribute,
  setAttributes: () => setAttributes,
  setDocument: () => setDocument,
  setElementBBox: () => setElementBBox,
  setElementStyle: () => setElementStyle,
  setElementStyles: () => setElementStyles,
  setPath: () => setPath,
  setWindow: () => setWindow,
  shadowOptionsDefs: () => shadowOptionsDefs,
  shallowClone: () => shallowClone,
  shapeHighlightOptionsDef: () => shapeHighlightOptionsDef,
  shapeSegmentOptions: () => shapeSegmentOptions,
  shapeSegmentation: () => shapeSegmentation,
  shapeValidator: () => shapeValidator,
  simpleMemorize: () => simpleMemorize,
  simpleMemorize2: () => simpleMemorize2,
  smoothPoints: () => smoothPoints,
  solveBezier: () => solveBezier,
  sortAndUniqueDates: () => sortAndUniqueDates,
  sortBasedOnArray: () => sortBasedOnArray,
  spanRange: () => spanRange,
  splitBezier2D: () => splitBezier2D,
  stepPoints: () => stepPoints,
  stopPageScrolling: () => stopPageScrolling,
  strictObjectKeys: () => strictObjectKeys,
  strictUnion: () => strictUnion,
  string: () => string,
  stringLength: () => stringLength,
  stringifyValue: () => stringifyValue,
  strokeOptionsDef: () => strokeOptionsDef,
  textOrSegments: () => textOrSegments,
  themeOperator: () => themeOperator,
  throttle: () => throttle,
  tickFormat: () => tickFormat,
  tickStep: () => tickStep,
  toArray: () => toArray,
  toDegrees: () => toDegrees,
  toFontString: () => toFontString,
  toIterable: () => toIterable,
  toPlainText: () => toPlainText,
  toRadians: () => toRadians,
  toTextString: () => toTextString,
  toolbarButtonOptionsDefs: () => toolbarButtonOptionsDefs,
  tooltipOptionsDefs: () => tooltipOptionsDefs,
  transformIntegratedCategoryValue: () => transformIntegratedCategoryValue,
  truncateLine: () => truncateLine,
  typeUnion: () => typeUnion,
  undocumented: () => undocumented,
  unguardTextEdges: () => unguardTextEdges,
  union: () => union,
  unionSymbol: () => unionSymbol,
  unique: () => unique,
  validate: () => validate,
  without: () => without,
  wrapLines: () => wrapLines,
  wrapText: () => wrapText,
  wrapTextOrSegments: () => wrapTextOrSegments,
  wrapTextSegments: () => wrapTextSegments
});
module.exports = __toCommonJS(main_exports);

// packages/ag-charts-core/src/globals/debug-logger.ts
var debug_logger_exports = {};
__export(debug_logger_exports, {
  Time: () => Time,
  check: () => check,
  create: () => create,
  inDevelopmentMode: () => inDevelopmentMode
});

// packages/ag-charts-core/src/utils/arrays.ts
function toArray(value) {
  if (value === void 0) {
    return [];
  }
  return Array.isArray(value) ? value : [value];
}
function unique(array2) {
  return Array.from(new Set(array2));
}
function groupBy(array2, iteratee) {
  return array2.reduce((result, item) => {
    const groupKey = iteratee(item);
    result[groupKey] ?? (result[groupKey] = []);
    result[groupKey].push(item);
    return result;
  }, {});
}
function arraysEqual(a, b) {
  if (a == null || b == null || a.length !== b.length) {
    return false;
  }
  for (let i = 0; i < a.length; i++) {
    if (Array.isArray(a[i]) && Array.isArray(b[i])) {
      if (!arraysEqual(a[i], b[i])) {
        return false;
      }
    } else if (a[i] !== b[i]) {
      return false;
    }
  }
  return true;
}
function circularSliceArray(data, size, offset = 0) {
  if (data.length === 0) {
    return [];
  }
  const result = [];
  for (let i = 0; i < size; i++) {
    result.push(data.at((i + offset) % data.length));
  }
  return result;
}
function sortBasedOnArray(baseArray, orderArray) {
  const orderMap = /* @__PURE__ */ new Map();
  for (const [index, item] of orderArray.entries()) {
    orderMap.set(item, index);
  }
  return baseArray.sort((a, b) => {
    const indexA = orderMap.get(a) ?? Infinity;
    const indexB = orderMap.get(b) ?? Infinity;
    return indexA - indexB;
  });
}
function dropFirstWhile(array2, cond) {
  let i = 0;
  while (i < array2.length && cond(array2[i])) {
    i += 1;
  }
  const deleteCount = i;
  if (deleteCount !== 0)
    array2.splice(0, deleteCount);
}
function dropLastWhile(array2, cond) {
  let i = array2.length - 1;
  while (i >= 0 && cond(array2[i])) {
    i -= 1;
  }
  const deleteCount = array2.length - 1 - i;
  if (deleteCount !== 0)
    array2.splice(array2.length - deleteCount, deleteCount);
}
function distribute(min, max, maxCount) {
  const values = [min];
  const step = Math.round((max - min) / (maxCount - 1));
  if (step > 0) {
    for (let i = min + step; i < max; i += step) {
      const length2 = values.push(i);
      if (length2 >= maxCount - 1)
        break;
    }
  }
  values.push(max);
  return values;
}

// packages/ag-charts-core/src/utils/dom/globalsProxy.ts
var verifiedGlobals = {};
if (typeof globalThis.window !== "undefined") {
  verifiedGlobals.window = globalThis.window;
}
if (typeof document !== "undefined") {
  verifiedGlobals.document = document;
} else if (typeof globalThis.global !== "undefined") {
  verifiedGlobals.document = globalThis.document;
}
function getDocument(propertyName) {
  return propertyName ? verifiedGlobals.document?.[propertyName] : verifiedGlobals.document;
}
function getWindow(propertyName) {
  return propertyName ? verifiedGlobals.window?.[propertyName] : verifiedGlobals.window;
}
function setDocument(document2) {
  verifiedGlobals.document = document2;
}
function setWindow(window) {
  verifiedGlobals.window = window;
}

// packages/ag-charts-core/src/utils/dom/domElements.ts
function createElement(tagName, className, style2) {
  const element = getDocument().createElement(tagName);
  if (typeof className === "object") {
    style2 = className;
    className = void 0;
  }
  if (className) {
    for (const name of className.split(" ")) {
      element.classList.add(name);
    }
  }
  if (style2) {
    Object.assign(element.style, style2);
  }
  return element;
}
function createSvgElement(elementName) {
  return getDocument().createElementNS("http://www.w3.org/2000/svg", elementName);
}

// packages/ag-charts-core/src/utils/dom/domDownload.ts
function downloadUrl(dataUrl, fileName) {
  const body = getDocument("body");
  const element = createElement("a", { display: "none" });
  element.href = dataUrl;
  element.download = fileName;
  body.appendChild(element);
  element.click();
  setTimeout(() => element.remove());
}

// packages/ag-charts-core/src/utils/dom/domEvents.ts
function attachListener(element, eventName, handler, options) {
  element.addEventListener(eventName, handler, options);
  return () => element.removeEventListener(eventName, handler, options);
}

// packages/ag-charts-core/src/utils/dom/domUtils.ts
var style;
function parseColor(color2) {
  if (style == null) {
    const OptionConstructor = getWindow("Option");
    style = new OptionConstructor().style;
  }
  style.color = color2;
  const result = style.color || null;
  style.color = "";
  return result;
}

// packages/ag-charts-core/src/globals/logger.ts
var logger_exports = {};
__export(logger_exports, {
  error: () => error,
  errorOnce: () => errorOnce,
  log: () => log,
  logGroup: () => logGroup,
  reset: () => reset,
  table: () => table,
  warn: () => warn,
  warnOnce: () => warnOnce
});
var doOnceCache = /* @__PURE__ */ new Set();
function log(...logContent) {
  console.log(...logContent);
}
function warn(message, ...logContent) {
  console.warn(`AG Charts - ${message}`, ...logContent);
}
function error(message, ...logContent) {
  if (typeof message === "object") {
    console.error(`AG Charts error`, message, ...logContent);
  } else {
    console.error(`AG Charts - ${message}`, ...logContent);
  }
}
function table(...logContent) {
  console.table(...logContent);
}
function guardOnce(messageOrError, prefix, cb) {
  let message;
  if (messageOrError instanceof Error) {
    message = messageOrError.message;
  } else if (typeof messageOrError === "string") {
    message = messageOrError;
  } else if (typeof messageOrError === "object") {
    message = JSON.stringify(messageOrError);
  } else {
    message = String(messageOrError);
  }
  const cacheKey = `${prefix}: ${message}`;
  if (doOnceCache.has(cacheKey))
    return;
  cb(messageOrError);
  doOnceCache.add(cacheKey);
}
function warnOnce(messageOrError, ...logContent) {
  guardOnce(messageOrError, "Logger.warn", (message) => warn(message, ...logContent));
}
function errorOnce(messageOrError, ...logContent) {
  guardOnce(messageOrError, "Logger.error", (message) => error(message, ...logContent));
}
function reset() {
  doOnceCache.clear();
}
function logGroup(name, cb) {
  console.groupCollapsed(name);
  try {
    return cb();
  } finally {
    console.groupEnd();
  }
}

// packages/ag-charts-core/src/globals/debug-logger.ts
var LongTimePeriodThreshold = 2e3;
var timeOfLastLog = Date.now();
function logTimeGap() {
  const timeSinceLastLog = Date.now() - timeOfLastLog;
  if (timeSinceLastLog > LongTimePeriodThreshold) {
    const prettyDuration = (Math.floor(timeSinceLastLog / 100) / 10).toFixed(1);
    log(`**** ${prettyDuration}s since last log message ****`);
  }
  timeOfLastLog = Date.now();
}
function create(...debugSelectors) {
  const resultFn = (...logContent) => {
    if (check(...debugSelectors)) {
      if (typeof logContent[0] === "function") {
        logContent = toArray(logContent[0]());
      }
      logTimeGap();
      log(...logContent);
    }
  };
  return Object.assign(resultFn, {
    check: () => check(...debugSelectors),
    group: (name, cb) => {
      if (check(...debugSelectors)) {
        return logGroup(name, cb);
      }
      return cb();
    }
  });
}
function check(...debugSelectors) {
  if (debugSelectors.length === 0) {
    debugSelectors.push(true);
  }
  const chartDebug = toArray(getWindow("agChartsDebug"));
  return chartDebug.some((selector) => debugSelectors.includes(selector));
}
function inDevelopmentMode(fn) {
  if (check("dev")) {
    return fn();
  }
}
function Time(name, opts = {}) {
  const { logResult = true, logStack = false, logArgs = false, logData } = opts;
  return function(_target, _propertyKey, descriptor) {
    const method = descriptor.value;
    descriptor.value = function(...args) {
      const start2 = performance.now();
      const result = method.apply(this, args);
      const duration = performance.now() - start2;
      const logMessage = { duration };
      if (logResult)
        logMessage.result = result;
      if (logArgs)
        logMessage.args = args;
      if (logStack)
        logMessage.stack = new Error("Stack trace for timing debug").stack;
      if (logData)
        logMessage.logData = logData(this);
      log(name, logMessage);
      return result;
    };
  };
}

// packages/ag-charts-core/src/globals/debug-metrics.ts
var debug_metrics_exports = {};
__export(debug_metrics_exports, {
  flush: () => flush,
  record: () => record
});
var metrics = /* @__PURE__ */ new Map();
function record(key, value) {
  if (!check("scene:stats:verbose"))
    return;
  metrics.set(key, value);
}
function flush() {
  const result = Object.fromEntries(metrics);
  metrics.clear();
  return result;
}

// packages/ag-charts-core/src/globals/enterpriseRegistry.ts
var enterpriseRegistry = {};

// packages/ag-charts-core/src/globals/moduleRegistry.ts
var moduleRegistry_exports = {};
__export(moduleRegistry_exports, {
  RegistryMode: () => RegistryMode,
  getAxisModule: () => getAxisModule,
  getChartModule: () => getChartModule,
  getPresetModule: () => getPresetModule,
  getSeriesModule: () => getSeriesModule,
  hasModule: () => hasModule,
  isEnterprise: () => isEnterprise,
  isIntegrated: () => isIntegrated,
  isModuleType: () => isModuleType,
  isUmd: () => isUmd,
  listModules: () => listModules,
  listModulesByType: () => listModulesByType,
  register: () => register,
  registerModules: () => registerModules,
  reset: () => reset2,
  setRegistryMode: () => setRegistryMode
});

// packages/ag-charts-core/src/interfaces/moduleDefinition.ts
var ModuleType = /* @__PURE__ */ ((ModuleType2) => {
  ModuleType2["Chart"] = "chart";
  ModuleType2["Axis"] = "axis";
  ModuleType2["Series"] = "series";
  ModuleType2["Plugin"] = "plugin";
  ModuleType2["AxisPlugin"] = "axis:plugin";
  ModuleType2["SeriesPlugin"] = "series:plugin";
  ModuleType2["Preset"] = "preset";
  return ModuleType2;
})(ModuleType || {});

// packages/ag-charts-core/src/globals/moduleRegistry.ts
var RegistryMode = /* @__PURE__ */ ((RegistryMode2) => {
  RegistryMode2["Enterprise"] = "enterprise";
  RegistryMode2["Integrated"] = "integrated";
  RegistryMode2["UMD"] = "umd";
  return RegistryMode2;
})(RegistryMode || {});
var registeredModes = /* @__PURE__ */ new Set();
var registeredModules = /* @__PURE__ */ new Map();
function registerModuleDefinition(def) {
  registeredModules.set(def.name, def);
  if (def.dependencies) {
    for (const dependency of def.dependencies) {
      register(dependency);
    }
  }
}
function register(def) {
  const existingDefinition = registeredModules.get(def.name);
  if (!existingDefinition) {
    registerModuleDefinition(def);
    return;
  }
  if (existingDefinition.version === def.version) {
    if (!existingDefinition.enterprise && def.enterprise) {
      registerModuleDefinition(def);
    }
    return;
  }
  throw new Error(
    [
      `AG Charts - Module '${def.name}' already registered with different version:`,
      `${existingDefinition.version} vs ${def.version}`,
      ``,
      `Check your package.json for conflicting dependencies - depending on your package manager`,
      `one of these commands may help:`,
      `- npm ls ag-charts-community`,
      `- yarn why ag-charts-community`
    ].join("\n")
  );
}
function registerModules(definitions) {
  for (const definition of definitions.flat()) {
    register(definition);
  }
}
function reset2() {
  registeredModes.clear();
  registeredModules.clear();
}
function hasModule(moduleName) {
  return registeredModules.has(moduleName);
}
function* listModules() {
  for (const definition of registeredModules.values()) {
    yield definition;
  }
}
function* listModulesByType(moduleType) {
  for (const definition of registeredModules.values()) {
    if (isModuleType(moduleType, definition)) {
      yield definition;
    }
  }
}
function getAxisModule(moduleName) {
  const definition = registeredModules.get(moduleName);
  if (isModuleType("axis" /* Axis */, definition)) {
    return definition;
  }
}
function getChartModule(moduleName) {
  const definition = registeredModules.get(moduleName);
  if (isModuleType("chart" /* Chart */, definition)) {
    return definition;
  }
  throw new Error(
    `AG Charts - Unknown chart type; Check options are correctly structured and series types are specified`
  );
}
function getPresetModule(moduleName) {
  const definition = registeredModules.get(moduleName);
  if (isModuleType("preset" /* Preset */, definition)) {
    return definition;
  }
}
function getSeriesModule(moduleName) {
  const definition = registeredModules.get(moduleName);
  if (isModuleType("series" /* Series */, definition)) {
    return definition;
  }
}
function setRegistryMode(registryFlag) {
  registeredModes.add(registryFlag);
}
function isEnterprise() {
  return registeredModes.has("enterprise" /* Enterprise */);
}
function isIntegrated() {
  return registeredModes.has("integrated" /* Integrated */);
}
function isUmd() {
  return registeredModes.has("umd" /* UMD */);
}
function isModuleType(moduleType, definition) {
  return definition?.type === moduleType;
}

// packages/ag-charts-core/src/utils/cleanupRegistry.ts
var CleanupRegistry = class {
  constructor() {
    this.callbacks = /* @__PURE__ */ new Set();
  }
  flush() {
    for (const cb of this.callbacks) {
      cb();
    }
    this.callbacks.clear();
  }
  merge(registry) {
    for (const cb of registry.callbacks) {
      this.callbacks.add(cb);
    }
  }
  register(...callbacks) {
    for (const cb of callbacks) {
      if (!cb)
        continue;
      this.callbacks.add(cb);
    }
  }
};

// packages/ag-charts-core/src/globals/moduleInstance.ts
var AbstractModuleInstance = class {
  constructor() {
    this.cleanup = new CleanupRegistry();
  }
  destroy() {
    this.cleanup.flush();
  }
};

// packages/ag-charts-core/src/interfaces/scaleTypes.ts
function extractDomain(value) {
  return value.domain;
}
var ScaleAlignment = /* @__PURE__ */ ((ScaleAlignment2) => {
  ScaleAlignment2[ScaleAlignment2["Leading"] = 0] = "Leading";
  ScaleAlignment2[ScaleAlignment2["Trailing"] = 1] = "Trailing";
  ScaleAlignment2[ScaleAlignment2["Interpolate"] = 2] = "Interpolate";
  return ScaleAlignment2;
})(ScaleAlignment || {});

// packages/ag-charts-core/src/classes/eventEmitter.ts
var EventEmitter = class {
  constructor() {
    this.events = /* @__PURE__ */ new Map();
  }
  /**
   * Registers an event listener.
   * @param eventName The event name to listen for.
   * @param listener The callback to be invoked on the event.
   * @returns A function to unregister the listener.
   */
  on(eventName, listener) {
    if (!this.events.has(eventName)) {
      this.events.set(eventName, /* @__PURE__ */ new Set());
    }
    this.events.get(eventName)?.add(listener);
    return () => this.off(eventName, listener);
  }
  /**
   * Unregisters an event listener.
   * @param eventName The event name to stop listening for.
   * @param listener The callback to be removed.
   */
  off(eventName, listener) {
    const eventListeners = this.events.get(eventName);
    if (eventListeners) {
      eventListeners.delete(listener);
      if (eventListeners.size === 0) {
        this.events.delete(eventName);
      }
    }
  }
  /**
   * Emits an event to all registered listeners.
   * @param eventName The name of the event to emit.
   * @param event The event payload.
   */
  emit(eventName, event) {
    const listeners = this.events.get(eventName);
    if (listeners) {
      for (const callback2 of listeners) {
        callback2(event);
      }
    }
  }
  /**
   * Clears all listeners for a specific event or all events if no event name is provided.
   * @param eventName (Optional) The name of the event to clear listeners for. If not provided, all listeners for all events are cleared.
   */
  clear(eventName) {
    if (eventName) {
      this.events.delete(eventName);
    } else {
      this.events.clear();
    }
  }
};

// packages/ag-charts-core/src/classes/lruCache.ts
var LRUCache = class {
  constructor(maxCacheSize) {
    this.maxCacheSize = maxCacheSize;
    this.store = /* @__PURE__ */ new Map();
    if (maxCacheSize <= 0) {
      throw new Error("LRUCache size must be greater than 0");
    }
  }
  get(key) {
    if (!this.store.has(key))
      return;
    const value = this.store.get(key);
    this.store.delete(key);
    this.store.set(key, value);
    return value;
  }
  has(key) {
    return this.store.has(key);
  }
  set(key, value) {
    this.store.set(key, value);
    if (this.store.size > this.maxCacheSize) {
      this.store.delete(this.store.keys().next().value);
    }
    return value;
  }
  clear() {
    this.store.clear();
  }
};

// packages/ag-charts-core/src/utils/numbers.ts
function clamp(min, value, max) {
  return Math.min(max, Math.max(min, value));
}
function inRange(value, range2, epsilon = 1e-10) {
  return value >= range2[0] - epsilon && value <= range2[1] + epsilon;
}
function isNumberEqual(a, b, epsilon = 1e-10) {
  return a === b || Math.abs(a - b) < epsilon;
}
function isNegative(value) {
  return Math.sign(value) === -1 || Object.is(value, -0);
}
function isInteger(value) {
  return value % 1 === 0;
}
function roundTo(value, decimals = 2) {
  const base = 10 ** decimals;
  return Math.round(value * base) / base;
}
function modulus(n, m) {
  return Math.floor(n % m + (n < 0 ? Math.abs(m) : 0));
}
function countFractionDigits(value) {
  if (Math.floor(value) === value) {
    return 0;
  }
  let valueString = String(value);
  let exponent = 0;
  if (value < 1e-6 || value >= 1e21) {
    let exponentString;
    [valueString, exponentString] = valueString.split("e");
    if (exponentString != null) {
      exponent = Number(exponentString);
    }
  }
  const decimalPlaces2 = valueString.split(".")[1]?.length ?? 0;
  return Math.max(decimalPlaces2 - exponent, 0);
}

// packages/ag-charts-core/src/utils/typeGuards.ts
function isDefined(val) {
  return val != null;
}
function isArray(value) {
  return Array.isArray(value);
}
function isBoolean(value) {
  return typeof value === "boolean";
}
function isDate(value) {
  return value instanceof Date;
}
function isValidDate(value) {
  return isDate(value) && !Number.isNaN(Number(value));
}
function isRegExp(value) {
  return value instanceof RegExp;
}
function isFunction(value) {
  return typeof value === "function";
}
function isObject(value) {
  return typeof value === "object" && value !== null && !isArray(value);
}
function isObjectLike(value) {
  return isArray(value) || isPlainObject(value);
}
function isPlainObject(value) {
  return typeof value === "object" && value !== null && value.constructor?.name === "Object";
}
function isEmptyObject(value) {
  if (typeof value !== "object" || value === null)
    return false;
  for (const _ in value) {
    return false;
  }
  return true;
}
function isString(value) {
  return typeof value === "string";
}
function isNumber(value) {
  return typeof value === "number";
}
function isFiniteNumber(value) {
  return Number.isFinite(value);
}
function isHtmlElement(value) {
  return typeof globalThis.window !== "undefined" && value instanceof HTMLElement;
}
function isEnumKey(enumObject, enumKey) {
  return isString(enumKey) && Object.keys(enumObject).includes(enumKey);
}
function isEnumValue(enumObject, enumValue) {
  return Object.values(enumObject).includes(enumValue);
}
function isSymbol(value) {
  return typeof value === "symbol";
}
function isColor(value) {
  return isString(value) && (value === "none" || parseColor(value) != null);
}
function isKeyOf(value, container) {
  return value in container;
}

// packages/ag-charts-core/src/modules/format/numberFormat.ts
var formatRegEx = /^(?:(.)?([<>=^]))?([+\-( ])?([$€£¥₣₹#])?(0)?(\d+)?(,)?(?:\.(\d+))?(~)?([%a-z])?$/i;
var surroundedRegEx = /^((?:[^#]|#[^{])*)#{([^}]+)}(.*)$/;
function isValidNumberFormat(value) {
  if (!isString(value))
    return false;
  const match = surroundedRegEx.exec(value);
  return formatRegEx.test(match ? match[2] : value);
}
function parseNumberFormat(format) {
  let prefix;
  let suffix;
  const surrounded = surroundedRegEx.exec(format);
  if (surrounded) {
    [, prefix, format, suffix] = surrounded;
  }
  const match = formatRegEx.exec(format);
  if (!match) {
    logger_exports.warnOnce(`The number formatter is invalid: ${format}`);
    return;
  }
  const [, fill, align, sign, symbol, zero, width2, comma, precision, trim, type] = match;
  return {
    fill,
    align,
    sign,
    symbol,
    zero,
    width: Number.parseInt(width2),
    comma,
    precision: Number.parseInt(precision),
    trim: Boolean(trim),
    type,
    prefix,
    suffix
  };
}
function createNumberFormatter(format) {
  const options = typeof format === "string" ? parseNumberFormat(format) : format;
  if (options == null)
    return;
  const { fill, align, sign = "-", symbol, zero, width: width2, comma, type, prefix = "", suffix = "", precision } = options;
  let { trim } = options;
  const precisionIsNaN = precision == null || Number.isNaN(precision);
  let formatBody;
  if (!type) {
    formatBody = decimalTypes["g"];
    trim = true;
  } else if (type in decimalTypes && type in integerTypes) {
    formatBody = precisionIsNaN ? integerTypes[type] : decimalTypes[type];
  } else if (type in decimalTypes) {
    formatBody = decimalTypes[type];
  } else if (type in integerTypes) {
    formatBody = integerTypes[type];
  } else {
    throw new Error(`The number formatter type is invalid: ${type}`);
  }
  const defaultFormatterPrecision = type ? 6 : 12;
  let formatterPrecision;
  if (!precisionIsNaN) {
    formatterPrecision = precision;
  }
  let padAlign = align;
  let padFill = fill;
  if (zero) {
    padFill ?? (padFill = "0");
    padAlign ?? (padAlign = "=");
  }
  return (n, fractionDigits) => {
    let effectivePrecision;
    if (formatterPrecision != null) {
      effectivePrecision = formatterPrecision;
    } else if (type === "f" || type === "%") {
      effectivePrecision = fractionDigits ?? defaultFormatterPrecision;
    } else if (type) {
      effectivePrecision = defaultFormatterPrecision;
    } else {
      effectivePrecision = fractionDigits ?? defaultFormatterPrecision;
    }
    let result = formatBody(n, effectivePrecision);
    if (trim) {
      result = removeTrailingZeros(result);
    }
    if (comma) {
      result = insertSeparator(result, comma);
    }
    const symbolPrefix = getSymbolPrefix(symbol, type);
    const symbolPrefixLength = symbolPrefix?.length ?? 0;
    if (symbolPrefix) {
      result = `${symbolPrefix}${result}`;
    }
    if (type === "s") {
      result = `${result}${getSIPrefix(n)}`;
    }
    if (type === "%" || type === "p") {
      result = `${result}%`;
    }
    const { value: signedResult, prefixLength: signPrefixLength } = addSign(n, result, sign);
    const totalPrefixLength = signPrefixLength + symbolPrefixLength;
    let output = signedResult;
    if (width2 != null && !Number.isNaN(width2)) {
      output = addPadding(output, width2, padFill ?? " ", padAlign, totalPrefixLength);
    }
    output = `${prefix}${output}${suffix}`;
    return output;
  };
}
var integerTypes = {
  b: (n) => absFloor(n).toString(2),
  c: (n) => String.fromCodePoint(n),
  d: (n) => Math.round(Math.abs(n)).toFixed(0),
  o: (n) => absFloor(n).toString(8),
  x: (n) => absFloor(n).toString(16),
  X: (n) => integerTypes.x(n).toUpperCase(),
  n: (n) => integerTypes.d(n),
  "%": (n) => `${absFloor(n * 100).toFixed(0)}`
};
var decimalTypes = {
  e: (n, f) => Math.abs(n).toExponential(f),
  E: (n, f) => decimalTypes.e(n, f).toUpperCase(),
  f: (n, f) => Math.abs(n).toFixed(f),
  F: (n, f) => decimalTypes.f(n, f).toUpperCase(),
  g: (n, f) => {
    if (n === 0) {
      return "0";
    }
    const a = Math.abs(n);
    const p = Math.floor(Math.log10(a));
    if (p >= -4 && p < f) {
      return a.toFixed(f - 1 - p);
    }
    return a.toExponential(f - 1);
  },
  G: (n, f) => decimalTypes.g(n, f).toUpperCase(),
  n: (n, f) => decimalTypes.g(n, f),
  p: (n, f) => decimalTypes.r(n * 100, f),
  r: (n, f) => {
    if (n === 0) {
      return "0";
    }
    const a = Math.abs(n);
    const p = Math.floor(Math.log10(a));
    const q = p - (f - 1);
    if (q <= 0) {
      return a.toFixed(-q);
    }
    const x = 10 ** q;
    return (Math.round(a / x) * x).toFixed();
  },
  s: (n, f) => {
    const p = getSIPrefixPower(n);
    return decimalTypes.r(n / 10 ** p, f);
  },
  "%": (n, f) => decimalTypes.f(n * 100, f)
};
var minSIPrefix = -24;
var maxSIPrefix = 24;
var siPrefixes = {
  [minSIPrefix]: "y",
  [-21]: "z",
  [-18]: "a",
  [-15]: "f",
  [-12]: "p",
  [-9]: "n",
  [-6]: "\xB5",
  [-3]: "m",
  [0]: "",
  [3]: "k",
  [6]: "M",
  [9]: "G",
  [12]: "T",
  [15]: "P",
  [18]: "E",
  [21]: "Z",
  [maxSIPrefix]: "Y"
};
var minusSign = "\u2212";
function absFloor(n) {
  return Math.floor(Math.abs(n));
}
function removeTrailingZeros(numString) {
  if (!numString.endsWith("0") || !numString.includes("."))
    return numString;
  let endIndex = numString.length - 1;
  while (endIndex > 0) {
    if (numString[endIndex] == "0") {
      endIndex -= 1;
    } else if (numString[endIndex] == ".") {
      endIndex -= 1;
      break;
    } else {
      break;
    }
  }
  return numString.substring(0, endIndex + 1);
}
function insertSeparator(numString, separator) {
  let dotIndex = numString.indexOf(".");
  if (dotIndex < 0) {
    dotIndex = numString.length;
  }
  const integerChars = numString.substring(0, dotIndex).split("");
  const fractionalPart = numString.substring(dotIndex);
  for (let i = integerChars.length - 3; i > 0; i -= 3) {
    integerChars.splice(i, 0, separator);
  }
  return `${integerChars.join("")}${fractionalPart}`;
}
function getSIPrefix(n) {
  return siPrefixes[getSIPrefixPower(n)];
}
function getSIPrefixPower(n) {
  return clamp(minSIPrefix, n ? Math.floor(Math.log10(Math.abs(n)) / 3) * 3 : 0, maxSIPrefix);
}
function addSign(num, numString, signType = "") {
  if (signType === "(") {
    if (num >= 0) {
      return { value: numString, prefixLength: 0 };
    }
    return { value: `(${numString})`, prefixLength: 1 };
  }
  let signPrefix = "";
  if (num < 0) {
    signPrefix = minusSign;
  } else if (signType === "+") {
    signPrefix = "+";
  } else if (signType === " ") {
    signPrefix = " ";
  }
  return { value: `${signPrefix}${numString}`, prefixLength: signPrefix.length };
}
function addPadding(numString, width2, fill = " ", align = ">", prefixLength = 0) {
  const padSize = width2 - numString.length;
  if (padSize <= 0) {
    return numString;
  }
  const padding2 = fill.repeat(padSize);
  if (align === "=") {
    const clampedPrefix = Math.min(Math.max(prefixLength, 0), numString.length);
    const start2 = numString.slice(0, clampedPrefix);
    const rest = numString.slice(clampedPrefix);
    return `${start2}${padding2}${rest}`;
  }
  if (align === ">" || !align) {
    return padding2 + numString;
  } else if (align === "<") {
    return `${numString}${padding2}`;
  } else if (align === "^") {
    const padLeft = Math.ceil(padSize / 2);
    const padRight = Math.floor(padSize / 2);
    return `${fill.repeat(padLeft)}${numString}${fill.repeat(padRight)}`;
  }
  return padding2 + numString;
}
function getSymbolPrefix(symbol, type) {
  if (symbol === "#") {
    switch (type) {
      case "b":
        return "0b";
      case "o":
        return "0o";