ag-charts-community/dist/package/main-modules.cjs.js

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

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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, from2, except, desc) => {
  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
    for (let key of __getOwnPropNames(from2))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
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-community/src/main-modules.ts
var main_modules_exports = {};
__export(main_modules_exports, {
  AllCartesianCommunityModules: () => AllCartesianCommunityModules,
  AllCommunityModules: () => AllCommunityModules,
  AllPolarCommunityModules: () => AllPolarCommunityModules,
  CartesianChartModule: () => CartesianChartModule,
  CategoryAxisModule: () => CategoryAxisModule,
  GroupedCategoryAxisModule: () => GroupedCategoryAxisModule,
  LogAxisModule: () => LogAxisModule,
  ModuleRegistry: () => import_ag_charts_core155.ModuleRegistry,
  NewAreaSeriesModule: () => NewAreaSeriesModule,
  NewBarSeriesModule: () => NewBarSeriesModule,
  NewBubbleSeriesModule: () => NewBubbleSeriesModule,
  NewDonutSeriesModule: () => NewDonutSeriesModule,
  NewHistogramSeriesModule: () => NewHistogramSeriesModule,
  NewLineSeriesModule: () => NewLineSeriesModule,
  NewPieSeriesModule: () => NewPieSeriesModule,
  NewScatterSeriesModule: () => NewScatterSeriesModule,
  NumberAxisModule: () => NumberAxisModule,
  PolarChartModule: () => PolarChartModule,
  TimeAxisModule: () => TimeAxisModule,
  UnitTimeAxisModule: () => UnitTimeAxisModule
});
module.exports = __toCommonJS(main_modules_exports);

// packages/ag-charts-community/src/api/preset/presetModules.ts
var import_ag_charts_core9 = require("ag-charts-core");

// packages/ag-charts-community/src/chart/commonOptionsDefs.ts
var import_ag_charts_core2 = require("ag-charts-core");

// packages/ag-charts-types/src/chart/navigatorOptions.ts
var __MINI_CHART_SERIES_OPTIONS = void 0;
var __VERIFY_MINI_CHART_SERIES_OPTIONS = void 0;
__VERIFY_MINI_CHART_SERIES_OPTIONS = __MINI_CHART_SERIES_OPTIONS;

// packages/ag-charts-types/src/chart/themeOptions.ts
var __THEME_OVERRIDES = void 0;
var __VERIFY_THEME_OVERRIDES = void 0;
__VERIFY_THEME_OVERRIDES = __THEME_OVERRIDES;

// packages/ag-charts-types/src/presets/gauge/commonOptions.ts
var __THEMEABLE_OPTIONS = void 0;
var __VERIFY_THEMEABLE_OPTIONS = void 0;
__VERIFY_THEMEABLE_OPTIONS = __THEMEABLE_OPTIONS;
var __AXIS_LABEL_OPTIONS = void 0;
var __VERIFY_AXIS_LABEL_OPTIONS = void 0;
__VERIFY_AXIS_LABEL_OPTIONS = __AXIS_LABEL_OPTIONS;

// packages/ag-charts-community/src/chart/axesOptionsDefs.ts
var import_ag_charts_core = require("ag-charts-core");
var timeIntervalUnit = (0, import_ag_charts_core.union)("millisecond", "second", "minute", "hour", "day", "month", "year");
var timeIntervalDefs = {
  unit: (0, import_ag_charts_core.required)(timeIntervalUnit),
  step: import_ag_charts_core.positiveNumberNonZero,
  epoch: import_ag_charts_core.date,
  utc: import_ag_charts_core.boolean
};
timeIntervalDefs.every = import_ag_charts_core.callback;
var timeInterval = (0, import_ag_charts_core.optionsDefs)(timeIntervalDefs, "a time interval object");
var numberFormatValidator = (0, import_ag_charts_core.attachDescription)(import_ag_charts_core.isValidNumberFormat, "a valid number format string");
var commonCrossLineLabelOptionsDefs = {
  enabled: import_ag_charts_core.boolean,
  text: import_ag_charts_core.string,
  padding: import_ag_charts_core.number,
  ...import_ag_charts_core.fontOptionsDef
};
var commonCrossLineOptionsDefs = (0, import_ag_charts_core.attachDescription)(
  {
    enabled: import_ag_charts_core.boolean,
    type: (0, import_ag_charts_core.required)((0, import_ag_charts_core.union)("line", "range")),
    range: (0, import_ag_charts_core.and)(
      (0, import_ag_charts_core.attachDescription)((_, { options }) => options.type === "range", "crossLine type to be 'range'"),
      (0, import_ag_charts_core.arrayOf)(import_ag_charts_core.defined),
      (0, import_ag_charts_core.arrayLength)(2, 2)
    ),
    value: (0, import_ag_charts_core.and)(
      (0, import_ag_charts_core.attachDescription)((_, { options }) => options.type === "line", "crossLine type to be 'line'"),
      import_ag_charts_core.defined
    ),
    label: commonCrossLineLabelOptionsDefs,
    fill: import_ag_charts_core.color,
    fillOpacity: import_ag_charts_core.ratio,
    ...import_ag_charts_core.strokeOptionsDef,
    ...import_ag_charts_core.lineDashOptionsDef
  },
  "cross-line options"
);
var cartesianCrossLineOptionsDefs = {
  ...commonCrossLineOptionsDefs,
  label: {
    ...commonCrossLineLabelOptionsDefs,
    position: (0, import_ag_charts_core.union)(
      "top",
      "left",
      "right",
      "bottom",
      "top-left",
      "top-right",
      "bottom-left",
      "bottom-right",
      "inside",
      "inside-left",
      "inside-right",
      "inside-top",
      "inside-bottom",
      "inside-top-left",
      "inside-bottom-left",
      "inside-top-right",
      "inside-bottom-right"
    ),
    rotation: import_ag_charts_core.number
  }
};
var commonAxisLabelOptionsDefs = {
  enabled: import_ag_charts_core.boolean,
  rotation: import_ag_charts_core.number,
  avoidCollisions: import_ag_charts_core.boolean,
  minSpacing: import_ag_charts_core.positiveNumber,
  spacing: import_ag_charts_core.positiveNumber,
  formatter: import_ag_charts_core.callback,
  itemStyler: (0, import_ag_charts_core.callbackDefs)({
    ...import_ag_charts_core.fontOptionsDef,
    spacing: import_ag_charts_core.number
  }),
  ...import_ag_charts_core.fontOptionsDef
};
var cartesianAxisLabelOptionsDefs = {
  autoRotate: import_ag_charts_core.boolean,
  autoRotateAngle: import_ag_charts_core.number,
  wrapping: (0, import_ag_charts_core.union)("never", "always", "hyphenate", "on-space"),
  truncate: (0, import_ag_charts_core.undocumented)(import_ag_charts_core.boolean),
  ...commonAxisLabelOptionsDefs
};
var cartesianNumericAxisLabel = {
  format: numberFormatValidator,
  ...cartesianAxisLabelOptionsDefs
};
var cartesianTimeAxisLabel = {
  format: (0, import_ag_charts_core.or)(import_ag_charts_core.string, import_ag_charts_core.object),
  ...cartesianAxisLabelOptionsDefs
};
var cartesianAxisTick = {
  enabled: import_ag_charts_core.boolean,
  width: import_ag_charts_core.positiveNumber,
  size: import_ag_charts_core.positiveNumber,
  stroke: import_ag_charts_core.color
};
var cartesianTimeAxisParentLevel = {
  enabled: import_ag_charts_core.boolean,
  label: cartesianTimeAxisLabel,
  tick: cartesianAxisTick
};
var commonAxisOptionsDefs = {
  reverse: import_ag_charts_core.boolean,
  gridLine: {
    enabled: import_ag_charts_core.boolean,
    width: import_ag_charts_core.positiveNumber,
    style: (0, import_ag_charts_core.arrayOfDefs)(
      {
        stroke: (0, import_ag_charts_core.or)(import_ag_charts_core.color, import_ag_charts_core.themeOperator),
        lineDash: (0, import_ag_charts_core.arrayOf)(import_ag_charts_core.positiveNumber)
      },
      "a grid-line style object array"
    )
  },
  interval: {
    values: (0, import_ag_charts_core.arrayOf)(import_ag_charts_core.defined),
    minSpacing: import_ag_charts_core.positiveNumber
  },
  label: commonAxisLabelOptionsDefs,
  line: {
    enabled: import_ag_charts_core.boolean,
    width: import_ag_charts_core.positiveNumber,
    stroke: import_ag_charts_core.color
  },
  tick: cartesianAxisTick,
  context: () => true
};
commonAxisOptionsDefs.layoutConstraints = (0, import_ag_charts_core.undocumented)({
  stacked: (0, import_ag_charts_core.required)(import_ag_charts_core.boolean),
  align: (0, import_ag_charts_core.required)((0, import_ag_charts_core.union)("start", "end")),
  unit: (0, import_ag_charts_core.required)((0, import_ag_charts_core.union)("percent", "px")),
  width: (0, import_ag_charts_core.required)(import_ag_charts_core.positiveNumber)
});
var cartesianAxisOptionsDefs = {
  ...commonAxisOptionsDefs,
  keys: (0, import_ag_charts_core.arrayOf)(import_ag_charts_core.string),
  crossLines: (0, import_ag_charts_core.arrayOfDefs)(cartesianCrossLineOptionsDefs, "a cross-line options array"),
  position: (0, import_ag_charts_core.union)("top", "right", "bottom", "left"),
  thickness: import_ag_charts_core.positiveNumber,
  maxThicknessRatio: import_ag_charts_core.ratio,
  title: {
    enabled: import_ag_charts_core.boolean,
    text: import_ag_charts_core.string,
    spacing: import_ag_charts_core.positiveNumber,
    formatter: import_ag_charts_core.callback,
    ...import_ag_charts_core.fontOptionsDef
  }
};
var cartesianAxisBandHighlightOptions = {
  enabled: import_ag_charts_core.boolean,
  ...import_ag_charts_core.fillOptionsDef,
  ...import_ag_charts_core.strokeOptionsDef,
  ...import_ag_charts_core.lineDashOptionsDef
};
cartesianAxisOptionsDefs.title._enabledFromTheme = (0, import_ag_charts_core.undocumented)(import_ag_charts_core.boolean);
function cartesianAxisCrosshairOptions(canFormat, timeFormat) {
  const baseCrosshairLabel = {
    enabled: import_ag_charts_core.boolean,
    xOffset: import_ag_charts_core.number,
    yOffset: import_ag_charts_core.number,
    formatter: (0, import_ag_charts_core.callbackOf)(import_ag_charts_core.string),
    renderer: (0, import_ag_charts_core.callbackOf)(
      (0, import_ag_charts_core.or)(
        import_ag_charts_core.string,
        (0, import_ag_charts_core.optionsDefs)(
          {
            text: import_ag_charts_core.string,
            color: import_ag_charts_core.color,
            backgroundColor: import_ag_charts_core.color,
            opacity: import_ag_charts_core.ratio
          },
          "crosshair label renderer result object"
        )
      )
    )
  };
  let crosshairLabel;
  if (canFormat) {
    crosshairLabel = {
      ...baseCrosshairLabel,
      format: timeFormat ? (0, import_ag_charts_core.or)(
        import_ag_charts_core.string,
        (0, import_ag_charts_core.optionsDefs)({
          millisecond: import_ag_charts_core.string,
          second: import_ag_charts_core.string,
          hour: import_ag_charts_core.string,
          day: import_ag_charts_core.string,
          month: import_ag_charts_core.string,
          year: import_ag_charts_core.string
        })
      ) : import_ag_charts_core.string
    };
  }
  return {
    enabled: import_ag_charts_core.boolean,
    snap: import_ag_charts_core.boolean,
    label: crosshairLabel ?? baseCrosshairLabel,
    ...import_ag_charts_core.strokeOptionsDef,
    ...import_ag_charts_core.lineDashOptionsDef
  };
}
function continuousAxisOptions(validDatum, supportTimeInterval) {
  return {
    min: (0, import_ag_charts_core.and)(validDatum, (0, import_ag_charts_core.lessThan)("max")),
    max: (0, import_ag_charts_core.and)(validDatum, (0, import_ag_charts_core.greaterThan)("min")),
    nice: import_ag_charts_core.boolean,
    interval: {
      step: supportTimeInterval ? (0, import_ag_charts_core.or)(import_ag_charts_core.positiveNumberNonZero, timeIntervalUnit, timeInterval) : import_ag_charts_core.positiveNumberNonZero,
      values: (0, import_ag_charts_core.arrayOf)(validDatum),
      minSpacing: (0, import_ag_charts_core.and)(import_ag_charts_core.positiveNumber, (0, import_ag_charts_core.lessThan)("maxSpacing")),
      maxSpacing: (0, import_ag_charts_core.and)(import_ag_charts_core.positiveNumber, (0, import_ag_charts_core.greaterThan)("minSpacing"))
    }
  };
}

// packages/ag-charts-community/src/chart/commonOptionsDefs.ts
var shapeValidator = (0, import_ag_charts_core2.or)(
  (0, import_ag_charts_core2.union)("circle", "cross", "diamond", "heart", "plus", "pin", "square", "star", "triangle"),
  import_ag_charts_core2.callback
);
var textWrapValidator = (0, import_ag_charts_core2.union)("never", "always", "hyphenate", "on-space");
var tooltipPlacementValidator = (0, import_ag_charts_core2.union)(
  "top",
  "right",
  "bottom",
  "left",
  "top-right",
  "bottom-right",
  "bottom-left",
  "top-left",
  "center"
);
var rangeValidator = (0, import_ag_charts_core2.or)(import_ag_charts_core2.positiveNumber, (0, import_ag_charts_core2.union)("exact", "nearest"));
var zoomAnchorPoint = (0, import_ag_charts_core2.union)("pointer", "start", "middle", "end");
var chartCaptionOptionsDefs = {
  enabled: import_ag_charts_core2.boolean,
  text: import_ag_charts_core2.string,
  textAlign: (0, import_ag_charts_core2.union)("left", "center", "right"),
  wrapping: (0, import_ag_charts_core2.union)("never", "always", "hyphenate", "on-space"),
  spacing: import_ag_charts_core2.positiveNumber,
  maxWidth: import_ag_charts_core2.positiveNumber,
  maxHeight: import_ag_charts_core2.positiveNumber,
  ...import_ag_charts_core2.fontOptionsDef
};
chartCaptionOptionsDefs.padding = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.positiveNumber);
var chartOverlayOptionsDefs = {
  enabled: import_ag_charts_core2.boolean,
  text: import_ag_charts_core2.string,
  renderer: (0, import_ag_charts_core2.callbackOf)((0, import_ag_charts_core2.or)(import_ag_charts_core2.string, import_ag_charts_core2.htmlElement))
};
var contextMenuItemLiterals = [
  "defaults",
  "download",
  "zoom-to-cursor",
  "pan-to-cursor",
  "reset-zoom",
  "toggle-series-visibility",
  "toggle-other-series",
  "separator"
];
var contextMenuItemObjectDef = {
  type: (0, import_ag_charts_core2.union)("action", "separator"),
  showOn: (0, import_ag_charts_core2.union)("always", "series-area", "series-node", "legend-item"),
  label: (0, import_ag_charts_core2.required)(import_ag_charts_core2.string),
  enabled: import_ag_charts_core2.boolean,
  action: import_ag_charts_core2.callback,
  items: (value, context) => contextMenuItemsArray(value, context)
};
contextMenuItemObjectDef.iconUrl = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.string);
var contextMenuItemObjectValidator = (0, import_ag_charts_core2.optionsDefs)(contextMenuItemObjectDef);
var contextMenuItemValidator = (0, import_ag_charts_core2.attachDescription)(
  (value, context) => {
    let result;
    if (typeof value === "string") {
      const allowedValues = contextMenuItemLiterals;
      if (allowedValues.includes(value)) {
        result = true;
      } else {
        result = { valid: false, invalid: [], cleared: null };
        result.invalid.push(
          new import_ag_charts_core2.ValidationError(
            import_ag_charts_core2.ErrorType.Invalid,
            `a context menu item string alias: ["${contextMenuItemLiterals.join('", "')}"]`,
            value,
            context.path
          )
        );
      }
    } else {
      result = contextMenuItemObjectValidator(value, context);
    }
    return result;
  },
  `a context menu item object or string alias: [${contextMenuItemLiterals.join(", ")}]`
);
var contextMenuItemsArray = (0, import_ag_charts_core2.arrayOf)(contextMenuItemValidator, "a menu items array", false);
var toolbarButtonOptionsDefs = {
  label: import_ag_charts_core2.string,
  ariaLabel: import_ag_charts_core2.string,
  tooltip: import_ag_charts_core2.string,
  icon: (0, import_ag_charts_core2.union)(
    "align-center",
    "align-left",
    "align-right",
    "arrow-drawing",
    "arrow-down-drawing",
    "arrow-up-drawing",
    "callout-annotation",
    "candlestick-series",
    "close",
    "comment-annotation",
    "date-range-drawing",
    "date-price-range-drawing",
    "delete",
    "disjoint-channel-drawing",
    "drag-handle",
    "fill-color",
    "line-style-solid",
    "line-style-dashed",
    "line-style-dotted",
    "high-low-series",
    "hlc-series",
    "hollow-candlestick-series",
    "horizontal-line-drawing",
    "line-color",
    "line-series",
    "line-with-markers-series",
    "locked",
    "measurer-drawing",
    "note-annotation",
    "ohlc-series",
    "pan-end",
    "pan-left",
    "pan-right",
    "pan-start",
    "parallel-channel-drawing",
    "position-bottom",
    "position-center",
    "position-top",
    "price-label-annotation",
    "price-range-drawing",
    "reset",
    "settings",
    "step-line-series",
    "text-annotation",
    "trend-line-drawing",
    "fibonacci-retracement-drawing",
    "fibonacci-retracement-trend-based-drawing",
    "unlocked",
    "vertical-line-drawing",
    "zoom-in",
    "zoom-out"
  )
};
var formatter = (0, import_ag_charts_core2.or)(import_ag_charts_core2.string, (0, import_ag_charts_core2.callbackOf)(import_ag_charts_core2.string));
var formatObjectValidator = (0, import_ag_charts_core2.optionsDefs)({
  x: formatter,
  y: formatter,
  angle: formatter,
  radius: formatter,
  size: formatter,
  color: formatter,
  label: formatter,
  secondaryLabel: formatter,
  sectorLabel: formatter,
  calloutLabel: formatter,
  legendItem: formatter
});
var commonChartOptionsDefs = {
  width: import_ag_charts_core2.positiveNumber,
  height: import_ag_charts_core2.positiveNumber,
  minWidth: import_ag_charts_core2.positiveNumber,
  minHeight: import_ag_charts_core2.positiveNumber,
  suppressFieldDotNotation: import_ag_charts_core2.boolean,
  title: chartCaptionOptionsDefs,
  subtitle: chartCaptionOptionsDefs,
  footnote: chartCaptionOptionsDefs,
  padding: {
    top: import_ag_charts_core2.positiveNumber,
    right: import_ag_charts_core2.positiveNumber,
    bottom: import_ag_charts_core2.positiveNumber,
    left: import_ag_charts_core2.positiveNumber
  },
  seriesArea: {
    clip: import_ag_charts_core2.boolean,
    padding: {
      top: import_ag_charts_core2.positiveNumber,
      right: import_ag_charts_core2.positiveNumber,
      bottom: import_ag_charts_core2.positiveNumber,
      left: import_ag_charts_core2.positiveNumber
    }
  },
  legend: {
    enabled: import_ag_charts_core2.boolean,
    position: (0, import_ag_charts_core2.union)("top", "right", "bottom", "left"),
    orientation: (0, import_ag_charts_core2.union)("horizontal", "vertical"),
    maxWidth: import_ag_charts_core2.positiveNumber,
    maxHeight: import_ag_charts_core2.positiveNumber,
    spacing: import_ag_charts_core2.positiveNumber,
    preventHidingAll: import_ag_charts_core2.boolean,
    reverseOrder: import_ag_charts_core2.boolean,
    toggleSeries: import_ag_charts_core2.boolean,
    item: {
      marker: {
        size: import_ag_charts_core2.positiveNumber,
        shape: shapeValidator,
        padding: import_ag_charts_core2.positiveNumber,
        strokeWidth: import_ag_charts_core2.positiveNumber
      },
      line: {
        length: import_ag_charts_core2.positiveNumber,
        strokeWidth: import_ag_charts_core2.positiveNumber
      },
      label: {
        maxLength: import_ag_charts_core2.positiveNumber,
        formatter: import_ag_charts_core2.callback,
        ...import_ag_charts_core2.fontOptionsDef
      },
      maxWidth: import_ag_charts_core2.positiveNumber,
      paddingX: import_ag_charts_core2.positiveNumber,
      paddingY: import_ag_charts_core2.positiveNumber,
      showSeriesStroke: import_ag_charts_core2.boolean
    },
    pagination: {
      marker: {
        size: import_ag_charts_core2.positiveNumber,
        shape: shapeValidator,
        padding: import_ag_charts_core2.positiveNumber
      },
      activeStyle: {
        ...import_ag_charts_core2.fillOptionsDef,
        ...import_ag_charts_core2.strokeOptionsDef
      },
      inactiveStyle: {
        ...import_ag_charts_core2.fillOptionsDef,
        ...import_ag_charts_core2.strokeOptionsDef
      },
      highlightStyle: {
        ...import_ag_charts_core2.fillOptionsDef,
        ...import_ag_charts_core2.strokeOptionsDef
      },
      label: import_ag_charts_core2.fontOptionsDef
    },
    listeners: {
      legendItemClick: import_ag_charts_core2.callback,
      legendItemDoubleClick: import_ag_charts_core2.callback
    }
  },
  gradientLegend: {
    enabled: import_ag_charts_core2.boolean,
    position: (0, import_ag_charts_core2.union)("top", "right", "bottom", "left"),
    spacing: import_ag_charts_core2.positiveNumber,
    reverseOrder: import_ag_charts_core2.boolean,
    gradient: {
      preferredLength: import_ag_charts_core2.positiveNumber,
      thickness: import_ag_charts_core2.positiveNumber
    },
    scale: {
      label: {
        ...import_ag_charts_core2.fontOptionsDef,
        minSpacing: import_ag_charts_core2.positiveNumber,
        format: numberFormatValidator,
        formatter: import_ag_charts_core2.callback
      },
      padding: import_ag_charts_core2.positiveNumber,
      interval: {
        step: import_ag_charts_core2.number,
        values: import_ag_charts_core2.array,
        minSpacing: (0, import_ag_charts_core2.and)(import_ag_charts_core2.positiveNumber, (0, import_ag_charts_core2.lessThan)("maxSpacing")),
        maxSpacing: (0, import_ag_charts_core2.and)(import_ag_charts_core2.positiveNumber, (0, import_ag_charts_core2.greaterThan)("minSpacing"))
      }
    }
  },
  listeners: {
    seriesNodeClick: import_ag_charts_core2.callback,
    seriesNodeDoubleClick: import_ag_charts_core2.callback,
    seriesVisibilityChange: import_ag_charts_core2.callback,
    click: import_ag_charts_core2.callback,
    doubleClick: import_ag_charts_core2.callback,
    annotations: import_ag_charts_core2.callback,
    zoom: import_ag_charts_core2.callback
  },
  loadGoogleFonts: import_ag_charts_core2.boolean,
  highlight: {
    range: (0, import_ag_charts_core2.union)("tooltip", "node")
  },
  overlays: {
    loading: chartOverlayOptionsDefs,
    noData: chartOverlayOptionsDefs,
    noVisibleSeries: chartOverlayOptionsDefs,
    unsupportedBrowser: chartOverlayOptionsDefs
  },
  tooltip: {
    enabled: import_ag_charts_core2.boolean,
    showArrow: import_ag_charts_core2.boolean,
    pagination: import_ag_charts_core2.boolean,
    delay: import_ag_charts_core2.positiveNumber,
    range: rangeValidator,
    wrapping: textWrapValidator,
    mode: (0, import_ag_charts_core2.union)("single", "shared", "compact"),
    position: {
      anchorTo: (0, import_ag_charts_core2.union)("pointer", "node", "chart"),
      placement: (0, import_ag_charts_core2.or)(tooltipPlacementValidator, (0, import_ag_charts_core2.arrayOf)(tooltipPlacementValidator)),
      xOffset: import_ag_charts_core2.number,
      yOffset: import_ag_charts_core2.number
    }
  },
  animation: {
    enabled: import_ag_charts_core2.boolean,
    duration: import_ag_charts_core2.positiveNumber
  },
  contextMenu: {
    enabled: import_ag_charts_core2.boolean,
    items: contextMenuItemsArray
  },
  context: () => true,
  dataSource: {
    getData: import_ag_charts_core2.callback
  },
  keyboard: {
    enabled: import_ag_charts_core2.boolean,
    tabIndex: import_ag_charts_core2.number
  },
  touch: {
    dragAction: (0, import_ag_charts_core2.union)("none", "drag", "hover")
  },
  ranges: {
    enabled: import_ag_charts_core2.boolean,
    buttons: (0, import_ag_charts_core2.arrayOfDefs)(
      {
        ...toolbarButtonOptionsDefs,
        value: (0, import_ag_charts_core2.or)(import_ag_charts_core2.number, (0, import_ag_charts_core2.and)((0, import_ag_charts_core2.arrayOf)((0, import_ag_charts_core2.or)(import_ag_charts_core2.number, import_ag_charts_core2.date)), (0, import_ag_charts_core2.arrayLength)(2, 2)), import_ag_charts_core2.callback)
      },
      "range button options array"
    )
  },
  // modules
  locale: {
    localeText: import_ag_charts_core2.object,
    getLocaleText: (0, import_ag_charts_core2.callbackOf)(import_ag_charts_core2.string)
  },
  background: {
    visible: import_ag_charts_core2.boolean,
    fill: import_ag_charts_core2.color,
    // enterprise
    image: {
      url: (0, import_ag_charts_core2.required)(import_ag_charts_core2.string),
      top: import_ag_charts_core2.number,
      right: import_ag_charts_core2.number,
      bottom: import_ag_charts_core2.number,
      left: import_ag_charts_core2.number,
      width: import_ag_charts_core2.positiveNumber,
      height: import_ag_charts_core2.positiveNumber,
      opacity: import_ag_charts_core2.ratio
    }
  },
  styleNonce: import_ag_charts_core2.string,
  sync: {
    enabled: import_ag_charts_core2.boolean,
    groupId: import_ag_charts_core2.string,
    axes: (0, import_ag_charts_core2.union)("x", "y", "xy"),
    nodeInteraction: import_ag_charts_core2.boolean,
    zoom: import_ag_charts_core2.boolean
  },
  zoom: {
    enabled: import_ag_charts_core2.boolean,
    enableAxisDragging: import_ag_charts_core2.boolean,
    enableDoubleClickToReset: import_ag_charts_core2.boolean,
    enablePanning: import_ag_charts_core2.boolean,
    enableScrolling: import_ag_charts_core2.boolean,
    enableSelecting: import_ag_charts_core2.boolean,
    enableTwoFingerZoom: import_ag_charts_core2.boolean,
    keepAspectRatio: import_ag_charts_core2.boolean,
    anchorPointX: zoomAnchorPoint,
    anchorPointY: zoomAnchorPoint,
    axes: (0, import_ag_charts_core2.union)("x", "y", "xy"),
    deceleration: (0, import_ag_charts_core2.or)((0, import_ag_charts_core2.union)("off", "short", "long"), import_ag_charts_core2.ratio),
    minVisibleItems: import_ag_charts_core2.positiveNumber,
    panKey: (0, import_ag_charts_core2.union)("alt", "ctrl", "meta", "shift"),
    scrollingStep: import_ag_charts_core2.ratio,
    autoScaling: {
      enabled: import_ag_charts_core2.boolean,
      padding: import_ag_charts_core2.ratio
    },
    buttons: {
      enabled: import_ag_charts_core2.boolean,
      buttons: (0, import_ag_charts_core2.arrayOfDefs)(
        {
          ...toolbarButtonOptionsDefs,
          value: (0, import_ag_charts_core2.union)("reset", "zoom-in", "zoom-out", "pan-left", "pan-right", "pan-start", "pan-end"),
          section: import_ag_charts_core2.string
        },
        "zoom button options array"
      ),
      visible: (0, import_ag_charts_core2.union)("always", "zoomed", "hover")
    }
  },
  formatter: (0, import_ag_charts_core2.or)((0, import_ag_charts_core2.callbackOf)(import_ag_charts_core2.string), formatObjectValidator)
};
commonChartOptionsDefs.dataSource.requestThrottle = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.positiveNumber);
commonChartOptionsDefs.dataSource.updateThrottle = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.positiveNumber);
commonChartOptionsDefs.dataSource.updateDuringInteraction = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.boolean);
commonChartOptionsDefs.zoom.enableIndependentAxes = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.boolean);
commonChartOptionsDefs.statusBar = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.defined);
commonChartOptionsDefs.foreground = (0, import_ag_charts_core2.undocumented)({
  visible: import_ag_charts_core2.boolean,
  text: import_ag_charts_core2.string,
  image: {
    url: import_ag_charts_core2.string,
    top: import_ag_charts_core2.number,
    right: import_ag_charts_core2.number,
    bottom: import_ag_charts_core2.number,
    left: import_ag_charts_core2.number,
    width: import_ag_charts_core2.positiveNumber,
    height: import_ag_charts_core2.positiveNumber,
    opacity: import_ag_charts_core2.ratio
  },
  ...import_ag_charts_core2.fillOptionsDef
});
commonChartOptionsDefs.overrideDevicePixelRatio = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.number);
commonChartOptionsDefs.sync.domainMode = (0, import_ag_charts_core2.undocumented)((0, import_ag_charts_core2.union)("direction", "position", "key"));
var commonSeriesThemeableOptionsDefs = {
  cursor: import_ag_charts_core2.string,
  context: () => true,
  showInLegend: import_ag_charts_core2.boolean,
  nodeClickRange: rangeValidator,
  listeners: {
    seriesNodeClick: import_ag_charts_core2.callback,
    seriesNodeDoubleClick: import_ag_charts_core2.callback
  },
  // TODO Remove in next major version
  highlightStyle: {
    item: { ...import_ag_charts_core2.fillOptionsDef, ...import_ag_charts_core2.strokeOptionsDef },
    series: {
      enabled: import_ag_charts_core2.boolean,
      dimOpacity: import_ag_charts_core2.ratio,
      strokeWidth: import_ag_charts_core2.positiveNumber
    }
  },
  highlight: (0, import_ag_charts_core2.highlightOptionsDef)(import_ag_charts_core2.shapeHighlightOptionsDef)
};
var commonSeriesOptionsDefs = {
  ...commonSeriesThemeableOptionsDefs,
  id: import_ag_charts_core2.string,
  visible: import_ag_charts_core2.boolean,
  context: () => true,
  data: import_ag_charts_core2.array
};
commonSeriesOptionsDefs.seriesGrouping = (0, import_ag_charts_core2.undocumented)(import_ag_charts_core2.defined);
var markerOptionsDefs = {
  enabled: import_ag_charts_core2.boolean,
  shape: shapeValidator,
  size: import_ag_charts_core2.positiveNumber,
  itemStyler: (0, import_ag_charts_core2.callbackDefs)({
    ...import_ag_charts_core2.fillOptionsDef,
    ...import_ag_charts_core2.strokeOptionsDef,
    ...import_ag_charts_core2.lineDashOptionsDef,
    shape: shapeValidator,
    size: import_ag_charts_core2.positiveNumber
  }),
  ...import_ag_charts_core2.fillOptionsDef,
  ...import_ag_charts_core2.strokeOptionsDef,
  ...import_ag_charts_core2.lineDashOptionsDef
};
var seriesLabelOptionsDefs = {
  enabled: import_ag_charts_core2.boolean,
  formatter: import_ag_charts_core2.callback,
  format: numberFormatValidator,
  ...import_ag_charts_core2.fontOptionsDef
};
var autoSizedLabelOptionsDefs = {
  ...seriesLabelOptionsDefs,
  lineHeight: import_ag_charts_core2.positiveNumber,
  minimumFontSize: import_ag_charts_core2.positiveNumber,
  wrapping: textWrapValidator,
  overflowStrategy: (0, import_ag_charts_core2.union)("ellipsis", "hide")
};
var errorBarThemeableOptionsDefs = {
  visible: import_ag_charts_core2.boolean,
  cap: {
    visible: import_ag_charts_core2.boolean,
    length: import_ag_charts_core2.positiveNumber,
    lengthRatio: import_ag_charts_core2.ratio,
    ...import_ag_charts_core2.strokeOptionsDef,
    ...import_ag_charts_core2.lineDashOptionsDef
  },
  ...import_ag_charts_core2.strokeOptionsDef,
  ...import_ag_charts_core2.lineDashOptionsDef
};
var errorBarOptionsDefs = {
  ...errorBarThemeableOptionsDefs,
  xLowerKey: import_ag_charts_core2.string,
  xUpperKey: import_ag_charts_core2.string,
  yLowerKey: import_ag_charts_core2.string,
  yUpperKey: import_ag_charts_core2.string,
  xLowerName: import_ag_charts_core2.string,
  xUpperName: import_ag_charts_core2.string,
  yLowerName: import_ag_charts_core2.string,
  yUpperName: import_ag_charts_core2.string,
  itemStyler: (0, import_ag_charts_core2.callbackDefs)({
    visible: import_ag_charts_core2.boolean,
    ...import_ag_charts_core2.strokeOptionsDef,
    ...import_ag_charts_core2.lineDashOptionsDef,
    cap: {
      visible: import_ag_charts_core2.boolean,
      length: import_ag_charts_core2.positiveNumber,
      lengthRatio: import_ag_charts_core2.ratio,
      ...import_ag_charts_core2.strokeOptionsDef,
      ...import_ag_charts_core2.lineDashOptionsDef
    }
  })
};
var tooltipOptionsDefs = {
  enabled: import_ag_charts_core2.boolean,
  showArrow: import_ag_charts_core2.boolean,
  range: rangeValidator,
  renderer: (0, import_ag_charts_core2.callbackOf)(
    (0, import_ag_charts_core2.or)(
      import_ag_charts_core2.string,
      (0, import_ag_charts_core2.optionsDefs)(
        {
          heading: import_ag_charts_core2.string,
          title: import_ag_charts_core2.string,
          data: (0, import_ag_charts_core2.arrayOfDefs)({
            label: (0, import_ag_charts_core2.required)(import_ag_charts_core2.string),
            value: (0, import_ag_charts_core2.required)(import_ag_charts_core2.string)
          })
        },
        "tooltip renderer result object"
      )
    )
  ),
  position: {
    anchorTo: (0, import_ag_charts_core2.union)("node", "pointer", "chart"),
    placement: (0, import_ag_charts_core2.or)(tooltipPlacementValidator, (0, import_ag_charts_core2.arrayOf)(tooltipPlacementValidator)),
    xOffset: import_ag_charts_core2.number,
    yOffset: import_ag_charts_core2.number
  },
  interaction: {
    enabled: import_ag_charts_core2.boolean
  }
};
var shadowOptionsDefs = {
  enabled: import_ag_charts_core2.boolean,
  xOffset: import_ag_charts_core2.number,
  yOffset: import_ag_charts_core2.number,
  blur: import_ag_charts_core2.positiveNumber,
  color: import_ag_charts_core2.color
};
var interpolationOptionsDefs = (0, import_ag_charts_core2.typeUnion)(
  {
    linear: {},
    smooth: {
      tension: import_ag_charts_core2.ratio
    },
    step: {
      position: (0, import_ag_charts_core2.union)("start", "middle", "end")
    }
  },
  "interpolation line options"
);

// packages/ag-charts-community/src/chart/series/cartesian/areaSeriesOptionsDef.ts
var import_ag_charts_core3 = require("ag-charts-core");
var highlight = (0, import_ag_charts_core3.multiSeriesHighlightOptionsDef)(import_ag_charts_core3.shapeHighlightOptionsDef, import_ag_charts_core3.shapeHighlightOptionsDef);
var areaSeriesThemeableOptionsDef = {
  showInMiniChart: import_ag_charts_core3.boolean,
  connectMissingData: import_ag_charts_core3.boolean,
  interpolation: interpolationOptionsDefs,
  label: seriesLabelOptionsDefs,
  marker: markerOptionsDefs,
  tooltip: tooltipOptionsDefs,
  shadow: shadowOptionsDefs,
  ...commonSeriesThemeableOptionsDefs,
  ...import_ag_charts_core3.fillOptionsDef,
  ...import_ag_charts_core3.strokeOptionsDef,
  ...import_ag_charts_core3.lineDashOptionsDef,
  highlight
};
var areaSeriesOptionsDef = {
  ...areaSeriesThemeableOptionsDef,
  ...commonSeriesOptionsDefs,
  highlight,
  type: (0, import_ag_charts_core3.required)((0, import_ag_charts_core3.constant)("area")),
  xKey: (0, import_ag_charts_core3.required)(import_ag_charts_core3.string),
  yKey: (0, import_ag_charts_core3.required)(import_ag_charts_core3.string),
  xName: import_ag_charts_core3.string,
  yName: import_ag_charts_core3.string,
  stacked: import_ag_charts_core3.boolean,
  stackGroup: import_ag_charts_core3.string,
  normalizedTo: import_ag_charts_core3.number
};

// packages/ag-charts-community/src/chart/series/cartesian/barSeriesOptionsDef.ts
var import_ag_charts_core4 = require("ag-charts-core");
var highlight2 = (0, import_ag_charts_core4.multiSeriesHighlightOptionsDef)(import_ag_charts_core4.barHighlightOptionsDef, import_ag_charts_core4.barHighlightOptionsDef);
var barSeriesThemeableOptionsDef = {
  direction: (0, import_ag_charts_core4.union)("horizontal", "vertical"),
  showInMiniChart: import_ag_charts_core4.boolean,
  cornerRadius: import_ag_charts_core4.positiveNumber,
  itemStyler: (0, import_ag_charts_core4.callbackDefs)({
    ...import_ag_charts_core4.fillOptionsDef,
    ...import_ag_charts_core4.strokeOptionsDef,
    ...import_ag_charts_core4.lineDashOptionsDef,
    cornerRadius: import_ag_charts_core4.positiveNumber
  }),
  crisp: import_ag_charts_core4.boolean,
  label: {
    ...seriesLabelOptionsDefs,
    placement: (0, import_ag_charts_core4.union)("inside-center", "inside-start", "inside-end", "outside-start", "outside-end"),
    padding: import_ag_charts_core4.positiveNumber
  },
  errorBar: errorBarThemeableOptionsDefs,
  shadow: shadowOptionsDefs,
  tooltip: tooltipOptionsDefs,
  ...commonSeriesThemeableOptionsDefs,
  highlight: highlight2,
  ...import_ag_charts_core4.fillOptionsDef,
  ...import_ag_charts_core4.strokeOptionsDef,
  ...import_ag_charts_core4.lineDashOptionsDef
};
barSeriesThemeableOptionsDef.sparklineMode = (0, import_ag_charts_core4.undocumented)(import_ag_charts_core4.boolean);
var barSeriesOptionsDef = {
  ...barSeriesThemeableOptionsDef,
  ...commonSeriesOptionsDefs,
  highlight: highlight2,
  type: (0, import_ag_charts_core4.required)((0, import_ag_charts_core4.constant)("bar")),
  xKey: (0, import_ag_charts_core4.required)(import_ag_charts_core4.string),
  yKey: (0, import_ag_charts_core4.required)(import_ag_charts_core4.string),
  xName: import_ag_charts_core4.string,
  yName: import_ag_charts_core4.string,
  direction: (0, import_ag_charts_core4.union)("horizontal", "vertical"),
  grouped: import_ag_charts_core4.boolean,
  stacked: import_ag_charts_core4.boolean,
  stackGroup: import_ag_charts_core4.string,
  normalizedTo: import_ag_charts_core4.number,
  legendItemName: import_ag_charts_core4.string,
  errorBar: errorBarOptionsDefs
};
barSeriesOptionsDef.pickOutsideVisibleMinorAxis = (0, import_ag_charts_core4.undocumented)(import_ag_charts_core4.boolean);
barSeriesOptionsDef.fastDataProcessing = (0, import_ag_charts_core4.undocumented)(import_ag_charts_core4.boolean);
barSeriesOptionsDef.focusPriority = (0, import_ag_charts_core4.undocumented)(import_ag_charts_core4.number);

// packages/ag-charts-community/src/chart/series/cartesian/lineSeriesOptionsDef.ts
var import_ag_charts_core5 = require("ag-charts-core");
var highlight3 = (0, import_ag_charts_core5.multiSeriesHighlightOptionsDef)(import_ag_charts_core5.shapeHighlightOptionsDef, import_ag_charts_core5.lineHighlightOptionsDef);
var lineSeriesThemeableOptionsDef = {
  title: import_ag_charts_core5.string,
  showInMiniChart: import_ag_charts_core5.boolean,
  connectMissingData: import_ag_charts_core5.boolean,
  interpolation: interpolationOptionsDefs,
  label: seriesLabelOptionsDefs,
  marker: markerOptionsDefs,
  tooltip: tooltipOptionsDefs,
  errorBar: errorBarThemeableOptionsDefs,
  ...commonSeriesThemeableOptionsDefs,
  ...import_ag_charts_core5.strokeOptionsDef,
  ...import_ag_charts_core5.lineDashOptionsDef,
  highlight: highlight3
};
lineSeriesThemeableOptionsDef.sparklineMode = (0, import_ag_charts_core5.undocumented)(import_ag_charts_core5.boolean);
var lineSeriesOptionsDef = {
  ...lineSeriesThemeableOptionsDef,
  ...commonSeriesOptionsDefs,
  highlight: highlight3,
  type: (0, import_ag_charts_core5.required)((0, import_ag_charts_core5.constant)("line")),
  xKey: (0, import_ag_charts_core5.required)(import_ag_charts_core5.string),
  yKey: (0, import_ag_charts_core5.required)(import_ag_charts_core5.string),
  xName: import_ag_charts_core5.string,
  yName: import_ag_charts_core5.string,
  stacked: import_ag_charts_core5.boolean,
  stackGroup: import_ag_charts_core5.string,
  normalizedTo: import_ag_charts_core5.number,
  legendItemName: import_ag_charts_core5.string,
  errorBar: errorBarOptionsDefs
};
lineSeriesOptionsDef.pickOutsideVisibleMinorAxis = (0, import_ag_charts_core5.undocumented)(import_ag_charts_core5.boolean);
lineSeriesOptionsDef.focusPriority = (0, import_ag_charts_core5.undocumented)(import_ag_charts_core5.number);

// packages/ag-charts-community/src/util/object.ts
var core = __toESM(require("ag-charts-core"));

// packages/ag-charts-community/src/util/decorator.ts
var BREAK_TRANSFORM_CHAIN = Symbol("BREAK");
var CONFIG_KEY = "__decorator_config";
var ACCESSORS_KEY = "__decorator_accessors";
function addFakeTransformToInstanceProperty(target, propertyKeyOrSymbol) {
  initialiseConfig(target, propertyKeyOrSymbol).optional = true;
}
function initialiseConfig(target, propertyKeyOrSymbol) {
  if (Object.getOwnPropertyDescriptor(target, CONFIG_KEY) == null) {
    Object.defineProperty(target, CONFIG_KEY, { value: {} });
  }
  if (Object.getOwnPropertyDescriptor(target, ACCESSORS_KEY) == null) {
    const parentAccessors = Object.getPrototypeOf(target)?.[ACCESSORS_KEY];
    const accessors = parentAccessors?.slice() ?? [];
    Object.defineProperty(target, ACCESSORS_KEY, { value: accessors });
  }
  const config = target[CONFIG_KEY];
  const propertyKey = propertyKeyOrSymbol.toString();
  if (config[propertyKey] != null) {
    return config[propertyKey];
  }
  config[propertyKey] = { setters: [], getters: [], observers: [] };
  const descriptor = Object.getOwnPropertyDescriptor(target, propertyKeyOrSymbol);
  let prevGet = descriptor?.get;
  let prevSet = descriptor?.set;
  if (prevGet == null || prevSet == null) {
    const accessors = target[ACCESSORS_KEY];
    let index = accessors.indexOf(propertyKeyOrSymbol);
    if (index === -1) {
      index = accessors.push(propertyKeyOrSymbol) - 1;
    }
    prevGet ?? (prevGet = function() {
      let accessorValues = this.__accessors;
      if (accessorValues == null) {
        accessorValues = accessors.slice().fill(void 0);
        Object.defineProperty(this, "__accessors", { value: accessorValues });
      }
      return accessorValues[index];
    });
    prevSet ?? (prevSet = function(value) {
      let accessorValues = this.__accessors;
      if (accessorValues == null) {
        accessorValues = accessors.slice().fill(void 0);
        Object.defineProperty(this, "__accessors", { value: accessorValues });
      }
      accessorValues[index] = value;
    });
  }
  const getter = function() {
    let value = prevGet.call(this);
    for (const transformFn of config[propertyKey].getters) {
      value = transformFn(this, propertyKeyOrSymbol, value);
      if (value === BREAK_TRANSFORM_CHAIN) {
        return;
      }
    }
    return value;
  };
  const setter = function(value) {
    const { setters, observers } = config[propertyKey];
    let oldValue;
    if (setters.some((f) => f.length > 2)) {
      oldValue = prevGet.call(this);
    }
    for (const transformFn of setters) {
      value = transformFn(this, propertyKeyOrSymbol, value, oldValue);
      if (value === BREAK_TRANSFORM_CHAIN) {
        return;
      }
    }
    prevSet.call(this, value);
    for (const observerFn of observers) {
      observerFn(this, value, oldValue);
    }
  };
  Object.defineProperty(target, propertyKeyOrSymbol, {
    set: setter,
    get: getter,
    enumerable: true,
    configurable: false
  });
  return config[propertyKey];
}
function addTransformToInstanceProperty(setTransform, getTransform, configMetadata) {
  return (target, propertyKeyOrSymbol) => {
    const config = initialiseConfig(target, propertyKeyOrSymbol);
    config.setters.push(setTransform);
    if (getTransform) {
      config.getters.unshift(getTransform);
    }
    if (configMetadata) {
      Object.assign(config, configMetadata);
    }
  };
}
function addObserverToInstanceProperty(setObserver) {
  return (target, propertyKeyOrSymbol) => {
    initialiseConfig(target, propertyKeyOrSymbol).observers.push(setObserver);
  };
}
function isDecoratedObject(target) {
  return typeof target !== "undefined" && CONFIG_KEY in target;
}
function listDecoratedProperties(target) {
  const targets = /* @__PURE__ */ new Set();
  while (isDecoratedObject(target)) {
    targets.add(target?.[CONFIG_KEY]);
    target = Object.getPrototypeOf(target);
  }
  return Array.from(targets).flatMap((configMap) => Object.keys(configMap));
}
function extractDecoratedProperties(target) {
  return listDecoratedProperties(target).reduce((result, key) => {
    result[key] = target[key] ?? null;
    return result;
  }, {});
}

// packages/ag-charts-community/src/util/object.ts
var { entries, isArray, isObject, isPlainObject } = core;
function objectsEqual(a, b) {
  if (Array.isArray(a)) {
    if (!Array.isArray(b))
      return false;
    if (a.length !== b.length)
      return false;
    return a.every((av, i) => objectsEqual(av, b[i]));
  } else if (isPlainObject(a)) {
    if (!isPlainObject(b))
      return false;
    return objectsEqualWith(a, b, objectsEqual);
  }
  return a === b;
}
function objectsEqualWith(a, b, cmp2) {
  if (Object.is(a, b))
    return true;
  for (const key of Object.keys(b)) {
    if (!(key in a))
      return false;
  }
  for (const key of Object.keys(a)) {
    if (!(key in b))
      return false;
    if (!cmp2(a[key], b[key]))
      return false;
  }
  return true;
}
function mergeDefaults(...sources) {
  const target = {};
  for (const source of sources) {
    if (!isObject(source))
      continue;
    const keys = isDecoratedObject(source) ? listDecoratedProperties(source) : Object.keys(source);
    for (const key of keys) {
      if (isPlainObject(target[key]) && isPlainObject(source[key])) {
        target[key] = mergeDefaults(target[key], source[key]);
      } else {
        target[key] ?? (target[key] = source[key]);
      }
    }
  }
  return target;
}
function merge(...sources) {
  const target = {};
  for (const source of sources) {
    if (!isObject(source))
      continue;
    const keys = isDecoratedObject(source) ? listDecoratedProperties(source) : Object.keys(source);
    for (const key of keys) {
      if (isPlainObject(target[key]) && isPlainObject(source[key])) {
        target[key] = merge(target[key], source[key]);
      } else if (!(key in target)) {
        target[key] ?? (target[key] = source[key]);
      }
    }
  }
  return target;
}
function mergeArrayDefaults(dataArray, ...itemDefaults) {
  if (itemDefaults && isArray(dataArray)) {
    return dataArray.map((item) => mergeDefaults(item, ...itemDefaults));
  }
  return dataArray;
}
function without(object3, keys) {
  const clone2 = { ...object3 };
  for (const key of keys) {
    delete clone2[key];
  }
  return clone2;
}
function getPath(object3, path) {
  const pathArray = isArray(path) ? path : path.split(".");
  return pathArray.reduce((value, pathKey) => value[pathKey], object3);
}
var SKIP_JS_BUILTINS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
function setPath(object3, path, newValue) {
  const pathArray = isArray(path) ? path.slice() : path.split(".");
  const lastKey = pathArray.pop();
  if (pathArray.some((p) => SKIP_JS_BUILTINS.has(p)))
    return;
  const lastObject = pathArray.reduce((value, pathKey) => value[pathKey], object3);
  lastObject[lastKey] = newValue;
  return lastObject[lastKey];
}
function partialAssign(keysToCopy, target, source) {
  if (source === void 0) {
    return target;
  }
  for (const key of keysToCopy) {
    const value = source[key];
    if (value !== void 0) {
      target[key] = value;
    }
  }
  return target;
}
function deepFreeze(obj) {
  if (obj == null || typeof obj !== "object" || !isPlainObject(obj)) {
    return obj;
  }
  Object.freeze(obj);
  Object.getOwnPropertyNames(obj).forEach((prop) => {
    const value = obj[prop];
    if (value !== null && (typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
      deepFreeze(value);
    }
  });
  return obj;
}

// packages/ag-charts-community/src/api/preset/presetUtils.ts
var IGNORED_PROP = Symbol("IGNORED_PROP");
function pickProps(opts, values) {
  const out = {};
  for (const key of Object.keys(values)) {
    const value = values[key];
    if (value !== IGNORED_PROP && Object.hasOwn(opts, key)) {
      out[key] = value;
    }
  }
  return out;
}

// packages/ag-charts-community/src/api/preset/gauge.ts
function tooltipOptions(opts) {
  const { enabled, mode, showArrow, range: range3, position, pagination, delay, wrapping, interaction, renderer, ...rest } = opts;
  const seriesTooltipOptions = pickProps(opts, {
    enabled,
    showArrow,
    range: range3,
    position,
    interaction,
    renderer,
    ...rest
  });
  const chartTooltipOptions = pickProps(opts, {
    enabled: IGNORED_PROP,
    showArrow: IGNORED_PROP,
    range: IGNORED_PROP,
    position: IGNORED_PROP,
    mode,
    pagination,
    delay,
    wrapping,
    ...rest
  });
  return { chartTooltipOptions, seriesTooltipOptions };
}
function radialGaugeOptions(opts) {
  const {
    animation,
    background,
    container,
    contextMenu,
    context,
    footnote,
    height: height2,
    listeners,
    locale,
    minHeight,
    minWidth,
    overrideDevicePixelRatio,
    padding,
    subtitle,
    theme,
    title,
    width: width2,
    type,
    cursor,
    nodeClickRange,
    tooltip = {},
    value,
    scale: scale2 = {},
    startAngle,
    endAngle,
    // eslint-disable-next-line sonarjs/deprecation
    highlightStyle,
    highlight: highlight5,
    segmentation,
    bar,
    needle,
    targets,
    outerRadius,
    innerRadius,
    outerRadiusRatio,
    innerRadiusRatio,
    cornerRadius,
    cornerMode,
    label,
    secondaryLabel,
    spacing,
    ...rest
  } = opts;
  const { chartTooltipOptions, seriesTooltipOptions } = tooltipOptions(tooltip);
  const chartOpts = pickProps(opts, {
    animation,
    background,
    container,
    contextMenu,
    context,
    footnote,
    height: height2,
    listeners,
    locale,
    minHeight,
    minWidth,
    overrideDevicePixelRatio,
    padding,
    subtitle,
    theme,
    title,
    tooltip: chartTooltipOptions,
    width: width2
  });
  const seriesOpts = pickProps(opts, {
    needle: needle != null ? { enabled: true, ...needle } : IGNORED_PROP,
    startAngle,
    endAngle,
    scale: scale2,
    type,
    cursor,
    context,
    nodeClickRange,
    tooltip: seriesTooltipOptions,
    value,
    highlightStyle,
    highlight: highlight5,
    segmentation,
    bar,
    targets,
    outerRadius,
    in