import { r as registerInstance, h, g as getElement, H as Host } from './index-090d31ca.js';
import { B as BaseDrawer, a as BaseChart, L as LayoutInputProcessor, P as ProcessorChain, b as LegendInputProcessor, c as LegendDrawer } from './legend-input-processor-122008c5.js';
import { m as map, X as XAxisInputProcessor, Y as YAxisInputProcessor, a as XAxisDrawer, b as YAxisDrawer } from './y-axis-input-processor-c7e05353.js';
import { f as flatNestedArray, c as convertArrayToNestedArray, s as sortAsExistArray, a as sortArrayOrNestedArray } from './array-7888f339.js';
import { s as sanitizeVegaComponent } from './component-7d906393.js';
import { I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
import { V as VegaComponentUsageRuntimeMetricsSlimmer, I as InjectVegaGlobalSlimmer } from './component-usage-runtime-metrics-46020a03.js';
import './typography-396de03f.js';
import './pixel-f32c07ce.js';
import './number-4398f2e1.js';

/**
 * D3 Time Format Polyfill - Lightweight date formatting and parsing.
 *
 * This is a drop-in replacement for d3-time-format, implementing only the methods
 * used in the Vega chart rendering system: timeFormat and timeParse.
 *
 * @see VD-5022 - [Zero Dependencies] remove d3 dependency
 */
/**
 * Mapping of format directives (e.g. %Y, %m) to their format functions.
 * Each function takes a Date and returns the formatted string segment.
 */
/* eslint-disable jsdoc/require-jsdoc */
const FORMAT_DIRECTIVES = {
  '%Y': (d) => String(d.getFullYear()),
  '%m': (d) => String(d.getMonth() + 1).padStart(2, '0'),
  '%d': (d) => String(d.getDate()).padStart(2, '0'),
  '%H': (d) => String(d.getHours()).padStart(2, '0'),
  '%I': (d) => {
    const hours = d.getHours() % 12;
    return String(hours === 0 ? 12 : hours).padStart(2, '0');
  },
  '%M': (d) => String(d.getMinutes()).padStart(2, '0'),
  '%S': (d) => String(d.getSeconds()).padStart(2, '0'),
  '%L': (d) => String(d.getMilliseconds()).padStart(3, '0'),
  '%b': (d) => {
    const months = [
      'Jan',
      'Feb',
      'Mar',
      'Apr',
      'May',
      'Jun',
      'Jul',
      'Aug',
      'Sep',
      'Oct',
      'Nov',
      'Dec',
    ];
    return months[d.getMonth()];
  },
  '%B': (d) => {
    const months = [
      'January',
      'February',
      'March',
      'April',
      'May',
      'June',
      'July',
      'August',
      'September',
      'October',
      'November',
      'December',
    ];
    return months[d.getMonth()];
  },
  '%a': (d) => {
    const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
    return days[d.getDay()];
  },
  '%p': (d) => (d.getHours() >= 12 ? 'PM' : 'AM'),
  '%%': () => '%',
};
/* eslint-enable jsdoc/require-jsdoc */
/**
 * Creates a date formatter function for the given specifier.
 * Mimics d3.timeFormat().
 *
 * Supported directives: %Y, %m, %d, %H, %I, %M, %S, %L, %b, %B, %a, %p, %%
 *
 * @param {string} specifier - Format specifier string (e.g., '%Y-%m-%d', '.%L', ':%S').
 * @returns {Function} A function that formats a Date into a string.
 */
function timeFormat(specifier) {
  return (date) => {
    let result = specifier;
    // Sort directives by length (longest first) to avoid partial matches
    const directives = Object.keys(FORMAT_DIRECTIVES).sort((a, b) => b.length - a.length);
    for (const directive of directives) {
      if (result.includes(directive)) {
        result = result.split(directive).join(FORMAT_DIRECTIVES[directive](date));
      }
    }
    return result;
  };
}
/**
 * Mapping of format directives to regex capture patterns for parsing.
 */
/* eslint-disable jsdoc/require-jsdoc */
const PARSE_PATTERNS = {
  /** Parses a 4-digit year. */
  '%Y': {
    regex: '(\\d{4})',
    handler: (m, p) => {
      p.year = parseInt(m, 10);
    },
  },
  /** Parses a 2-digit month. */
  '%m': {
    regex: '(\\d{2})',
    handler: (m, p) => {
      p.month = parseInt(m, 10) - 1;
    },
  },
  /** Parses a 2-digit day. */
  '%d': {
    regex: '(\\d{2})',
    handler: (m, p) => {
      p.day = parseInt(m, 10);
    },
  },
  /** Parses a 2-digit hour (24h). */
  '%H': {
    regex: '(\\d{2})',
    handler: (m, p) => {
      p.hours = parseInt(m, 10);
    },
  },
  /** Parses a 2-digit hour (12h). */
  '%I': {
    regex: '(\\d{2})',
    handler: (m, p) => {
      p.hours = parseInt(m, 10);
    },
  },
  /** Parses a 2-digit minute. */
  '%M': {
    regex: '(\\d{2})',
    handler: (m, p) => {
      p.minutes = parseInt(m, 10);
    },
  },
  /** Parses a 2-digit second. */
  '%S': {
    regex: '(\\d{2})',
    handler: (m, p) => {
      p.seconds = parseInt(m, 10);
    },
  },
  /** Parses a 3-digit millisecond. */
  '%L': {
    regex: '(\\d{3})',
    handler: (m, p) => {
      p.milliseconds = parseInt(m, 10);
    },
  },
};
/**
 * Creates a date parser function for the given specifier.
 * Mimics d3.timeParse().
 *
 * Supported directives: %Y, %m, %d, %H, %I, %M, %S, %L
 *
 * @param {string} specifier - Parse specifier string (e.g., '%Y-%m-%d').
 * @returns {Function} A function that parses a string into a Date, or null on failure.
 */
// eslint-disable-next-line spellcheck/spell-checker
// eslint-disable-next-line @heartlandone/vega-sandbox-pr-2872-b08ecf441325d54aeb57d51d0ee39c8e6e6ac495-eslint/vega-mandatory-method-return-corresponds-to-comments-tag-verify
function timeParse(specifier) {
  // Build regex and capture order from specifier
  const captureOrder = [];
  let regexStr = '^';
  let remaining = specifier;
  while (remaining.length > 0) {
    let matched = false;
    // Sort by key length (longest first) to avoid partial matches
    const keys = Object.keys(PARSE_PATTERNS).sort((a, b) => b.length - a.length);
    for (const key of keys) {
      if (remaining.startsWith(key)) {
        regexStr += PARSE_PATTERNS[key].regex;
        captureOrder.push({ handler: PARSE_PATTERNS[key].handler });
        remaining = remaining.slice(key.length);
        matched = true;
        break;
      }
    }
    if (!matched) {
      // Escape special regex chars for literal characters
      regexStr += remaining[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
      remaining = remaining.slice(1);
    }
  }
  regexStr += '$';
  const regex = new RegExp(regexStr);
  return (dateString) => {
    const match = dateString.match(regex);
    if (!match)
      return null;
    const parts = {
      year: 1970,
      month: 0,
      day: 1,
      hours: 0,
      minutes: 0,
      seconds: 0,
      milliseconds: 0,
    };
    for (let i = 0; i < captureOrder.length; i++) {
      captureOrder[i].handler(match[i + 1], parts);
    }
    return new Date(parts.year, parts.month, parts.day, parts.hours, parts.minutes, parts.seconds, parts.milliseconds);
  };
}

/**
 * D3 Time Polyfill - Lightweight time interval functions.
 *
 * This is a drop-in replacement for d3-time, implementing only the time interval
 * floor functions used in the Vega chart time axis label formatter:
 * timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear.
 *
 * Each function floors a Date to the nearest interval boundary, which is used
 * to determine the appropriate label granularity for time-series chart axes.
 *
 * @see VD-5022 - [Zero Dependencies] remove d3 dependency
 */
/**
 * Floors a date to the nearest second boundary.
 * Used to detect sub-second (millisecond) granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to the nearest second.
 */
function timeSecond(date) {
  const d = new Date(date);
  d.setMilliseconds(0);
  return d;
}
/**
 * Floors a date to the nearest minute boundary.
 * Used to detect sub-minute (second) granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to the nearest minute.
 */
function timeMinute(date) {
  const d = new Date(date);
  d.setSeconds(0, 0);
  return d;
}
/**
 * Floors a date to the nearest hour boundary.
 * Used to detect sub-hour (minute) granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to the nearest hour.
 */
function timeHour(date) {
  const d = new Date(date);
  d.setMinutes(0, 0, 0);
  return d;
}
/**
 * Floors a date to the start of the day (midnight).
 * Used to detect sub-day (hour) granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to midnight.
 */
function timeDay(date) {
  const d = new Date(date);
  d.setHours(0, 0, 0, 0);
  return d;
}
/**
 * Floors a date to the start of the week (Sunday).
 * Used to distinguish day vs week label granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to the start of the week (Sunday at midnight).
 */
function timeWeek(date) {
  const d = new Date(date);
  d.setHours(0, 0, 0, 0);
  d.setDate(d.getDate() - d.getDay());
  return d;
}
/**
 * Floors a date to the first of the month.
 * Used to detect sub-month granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to the 1st of the month at midnight.
 */
function timeMonth(date) {
  const d = new Date(date);
  d.setDate(1);
  d.setHours(0, 0, 0, 0);
  return d;
}
/**
 * Floors a date to January 1st of the year.
 * Used to detect sub-year (month) granularity.
 *
 * @param {Date} date - Input date.
 * @returns {Date} A new Date floored to January 1st at midnight.
 */
function timeYear(date) {
  const d = new Date(date);
  d.setMonth(0, 1);
  d.setHours(0, 0, 0, 0);
  return d;
}

/** The PathDrawer class draws a path on a chart using provided data and color options. */
class PathDrawer extends BaseDrawer {
  /** This function adds interaction support */
  // eslint-disable-next-line @typescript-eslint/no-empty-function
  addInteractionSupport() { }
  /**
   * This function draws a path on a chart using specified options.
   */
  draw() {
    const { positions, colors } = this.options.renderOptions;
    let renderPositions = positions;
    if (positions && positions[0] && !Array.isArray(positions[0])) {
      renderPositions = [positions];
    }
    renderPositions.forEach((item, index) => {
      const color = this.getColorByIndex(index, colors);
      this.renderer.drawLinePath(item, this.getColorFromToken(color));
      item.forEach((position) => {
        this.renderer.drawCircle(position, 4, this.getColorFromToken('bg-primary'), 2, this.getColorFromToken(color));
      });
    });
  }
}

/** The `LinePathInputProcessor` class generates chart path options based on input data and previous scale records for a line chart. */
class LinePathInputProcessor {
  /**
   * This function generates chart path options based on input data and previous scale records.
   *
   * @param {ChartOptions<LineChartDataType>} input - The input parameter is an object of type ChartOptions that contains two properties:
   * dataSource and colors. The dataSource property is of type LineChartDataType and represents the data
   * used to generate the chart. The colors property is an array of strings that represents the colors
   * to be used for the chart.
   * @param {ScaleRecordType} previousOutput - The `previousOutput` parameter is of type
   * `ScaleRecordType` and is the output of the previous step in the chart rendering process. It
   * contains the x and y scales that were calculated in the previous step and are used in this step to
   * generate the positions for the chart path.
   * @returns {ChartPathOptions} A `ChartPathOptions` object is being returned, which contains an array of `positions`
   * generated using the `pathPositionGenerator` and the `xScale` and `yScale` scales from the
   * `previousOutput`, as well as the `colors` from the `dataSource`.
   */
  process(input, previousOutput) {
    const { dataSource, colors } = input;
    const { xScale, yScale } = previousOutput;
    return {
      positions: this.getPathPositions(dataSource, xScale, yScale),
      colors,
    };
  }
  /**
   * convert array to array[], convert x,y position to relative position
   *
   * @param {LineChartDataType['dataSource']} originData origin line data source
   * @param {AxisScale<AxisDomain>} xScale x scale
   * @param {AxisScale<AxisDomain>} yScale y scale
   * @returns {ChartPosition[][]} x,y relative position
   */
  getPathPositions(originData, xScale, yScale) {
    const flatData = flatNestedArray(originData);
    let dataLengthArr = [];
    const flatPathData = flatData.map(({ x, y }) => {
      return {
        x: xScale(x),
        y: yScale(y),
      };
    });
    let pathData = [];
    if (originData && Array.isArray(originData[0])) {
      dataLengthArr = originData.map((item) => item.length);
      pathData = convertArrayToNestedArray(flatPathData, dataLengthArr);
    }
    else {
      pathData = [flatPathData];
    }
    return pathData;
  }
}

/** The FormatTimePositionsInputProcessor class processes input data for a line chart by formatting time positions if the x-axis type is 'time'. */
class FormatTimePositionsInputProcessor {
  /**
   * This function processes chart options for a line chart, converting the x-axis data to a time format if necessary.
   *
   * @param {ChartOptions<LineChartDataType>} input - A ChartOptions object that contains the data source and configuration options for a line chart.
   * @returns {ChartOptions<LineChartDataType>} A modified version of the input ChartOptions object with the dataSource property
   * potentially transformed based on the xAxis type.
   */
  process(input) {
    const { dataSource, xAxis } = input;
    const xAxisType = (xAxis === null || xAxis === void 0 ? void 0 : xAxis.type) || 'value';
    let renderData = dataSource;
    if (xAxisType === 'time') {
      renderData = this.formatTimePositionArray(dataSource);
    }
    input.dataSource = renderData;
    return input;
  }
  /**
   * format date position array function for chart, parse date string yyyy-MM-DD to date
   *
   * @param {StringCategorizedChartData[] | StringCategorizedChartData[][]} data data source
   * @returns {DateCategorizedChartData[] | DateCategorizedChartData[][]} result array
   */
  formatTimePositionArray(data) {
    let result = [];
    let lengthArray = [];
    const flatArray = flatNestedArray(data);
    const flatArray_date = map(flatArray, (d) => {
      return { x: (typeof d.x === 'string' ? timeParse('%Y-%m-%d')(d.x) : d.x), y: d.y };
    });
    if (data && Array.isArray(data[0])) {
      lengthArray = data.map((item) => item.length);
      result = convertArrayToNestedArray(flatArray_date, lengthArray);
    }
    else {
      result = flatArray_date;
    }
    return result;
  }
}

/** The SortPositionsInputProcessor class sorts the data source of a line chart based on the type of x-axis. */
class SortPositionsInputProcessor {
  /**
   * This function sorts the data source of a line chart based on the type of x-axis.
   *
   * @param {ChartOptions<LineChartDataType>} input - The input parameter is an object of type ChartOptions with a generic type of
   * LineChartDataType. It contains the data source and configuration options for a line chart,
   * including the x-axis type.
   * @returns {ChartOptions<LineChartDataType>} a modified version of the input `ChartOptions` object with the `dataSource` property
   * sorted based on the `xAxis` type. The modified `ChartOptions` object is of type
   * `ChartOptions<LineChartDataType>`.
   */
  process(input) {
    const { dataSource, xAxis } = input;
    const xAxisType = (xAxis === null || xAxis === void 0 ? void 0 : xAxis.type) || 'value';
    let renderData = dataSource;
    switch (xAxisType) {
      case 'time':
        renderData = sortArrayOrNestedArray(dataSource, (data) => data.x.valueOf());
        break;
      case 'value':
        renderData = sortArrayOrNestedArray(dataSource, (data) => data.x);
        break;
      case 'category':
        renderData = sortAsExistArray(dataSource, (item) => item.x, xAxis.sorter);
    }
    input.dataSource = renderData;
    return input;
  }
}

/** The XAxisInputProcessor class generates X-axis options for a line chart based on input data and previous layout results. */
class XAxisLabelFormatterInputProcessor {
  constructor() {
    this.formatMillisecond = timeFormat('.%L');
    this.formatSecond = timeFormat(':%S');
    this.formatMinute = timeFormat('%I:%M');
    //return 18:00
    this.formatHour = timeFormat('%H:00');
    //return 01
    this.formatDay = timeFormat('%d');
    //return Jan 01
    this.formatWeek = timeFormat('%b %d');
    //return Jan
    this.formatMonth = timeFormat('%b');
    //return 2023
    this.formatYear = timeFormat('%Y');
  }
  /**
   * This function checks if the xAxis type is 'time' and sets a tickFormat if a labelFormatter is not provided.
   *
   * @param {ChartOptions<unknown>} input - An object containing chart options, including the type of x-axis and a label
   * formatter function.
   * @param {ChartExtend<AxisScale<AxisDomain>>} previousOutput - `previousOutput` is a parameter that represents the output of the previous
   * step in the charting process. It is of type `ChartExtend<AxisScale<AxisDomain>>`, which is an
   * object that contains information about the chart's axis scales. This parameter is used to update
   * the axis scale information
   * @returns {ChartExtend<AxisScale<AxisDomain>>} a `ChartExtend` object that contains an `AxisScale` object with a tick format function.
   * The tick format function is either the `timeFormatter` function or the previous tick format
   * function if the `xAxisType` is not `'time'`.
   */
  process(input, previousOutput) {
    const { xAxis } = input;
    const xAxisType = (xAxis === null || xAxis === void 0 ? void 0 : xAxis.type) || 'value';
    if (xAxisType === 'time' && typeof previousOutput.labelFormatter !== 'function') {
      // eslint-disable-next-line jsdoc/require-jsdoc
      previousOutput.scale['tickFormat'] = () => this.timeFormatter.bind(this);
    }
    return previousOutput;
  }
  /**
   * override the scaleTime default ticks label formatter function
   * The function formats a given date object based on its time interval using a set of predefined format strings.
   *
   * @param {Date} date - The input date that needs to be formatted.
   * @returns {string} A string representing the formatted date based on the input date parameter. The format of
   * the string depends on the time interval between the input date and the current time, and is
   * determined by the conditional statements in the function.
   */
  timeFormatter(date) {
    return (timeSecond(date) < date
      ? this.formatMillisecond
      : timeMinute(date) < date
        ? this.formatSecond
        : timeHour(date) < date
          ? this.formatMinute
          : timeDay(date) < date
            ? this.formatHour
            : timeMonth(date) < date
              ? timeWeek(date) < date
                ? this.formatDay
                : this.formatWeek
              : timeYear(date) < date
                ? this.formatMonth
                : this.formatYear)(date);
  }
}

/**
 * The LineChart class is a TypeScript implementation of a line chart that extends the BaseChart class
 * and includes methods for creating a drawer chain
 */
class LineChart extends BaseChart {
  constructor() {
    super(...arguments);
    this.layoutInputProcessor = new LayoutInputProcessor();
    this.lineDataSourceInputProcessorChain = new ProcessorChain([new FormatTimePositionsInputProcessor(), new SortPositionsInputProcessor()]);
    this.xAxisInputProcessorChain = new ProcessorChain([
      this.layoutInputProcessor,
      new XAxisInputProcessor(),
      new XAxisLabelFormatterInputProcessor(),
    ]);
    this.yAxisInputProcessorChain = new ProcessorChain([this.layoutInputProcessor, new YAxisInputProcessor()]);
    this.legendInputProcessorChain = new ProcessorChain([
      this.layoutInputProcessor,
      new LegendInputProcessor(),
    ]);
    this.linePathInputProcessor = new LinePathInputProcessor();
  }
  /**
   * This function creates an array of BaseDrawer objects for rendering a chart with axes, legends, and paths.
   *
   * @param {BaseRenderer<SVGElement | HTMLCanvasElement>} renderer - an instance of a BaseRenderer class that can render SVG or Canvas elements.
   * @param {BaseInteractor<SVGElement | HTMLCanvasElement>} interactor - an instance of a BaseInteractor class.
   * @returns {BaseDrawer<unknown>[]} An array of BaseDrawer array.
   */
  createDrawerChain(renderer, interactor) {
    const lineRenderOptionsOutput = this.lineDataSourceInputProcessorChain.process(this.options);
    const xAxisOutput = this.xAxisInputProcessorChain.process(lineRenderOptionsOutput);
    const yAxisOutput = this.yAxisInputProcessorChain.process(lineRenderOptionsOutput);
    return [
      new XAxisDrawer(renderer, interactor, {
        renderOptions: xAxisOutput,
      }),
      new YAxisDrawer(renderer, interactor, {
        renderOptions: yAxisOutput,
      }),
      new LegendDrawer(renderer, interactor, {
        renderOptions: this.legendInputProcessorChain.process(this.options),
      }),
      new PathDrawer(renderer, interactor, {
        renderOptions: this.linePathInputProcessor.process(lineRenderOptionsOutput, {
          xScale: xAxisOutput.scale,
          yScale: yAxisOutput.scale,
        }),
      }),
    ];
  }
}

const vegaLineChartCss = ".vega-chart-legend-item{cursor:pointer}.vega-chart-line-path:hover{stroke-width:5}:host{display:block}";

var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
    r = Reflect.decorate(decorators, target, key, desc);
  else
    for (var i = decorators.length - 1; i >= 0; i--)
      if (d = decorators[i])
        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
  return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __rest = (undefined && undefined.__rest) || function (s, e) {
  var t = {};
  for (var p in s)
    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
      t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function")
    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
        t[p[i]] = s[p[i]];
    }
  return t;
};
const VegaLineChart = class {
  constructor(hostRef) {
    registerInstance(this, hostRef);
    this.globalSlimmers = {};
    this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer();
  }
  watchOptionsHandel(options) {
    this.updateChart(options);
  }
  disconnectedCallback() {
    this.chart = null;
    this.reRenderTimer && clearTimeout(this.reRenderTimer);
  }
  componentWillLoad() {
    this.updateChart(this.options);
  }
  /**
   * Invoke this method to render the chart using the existing options.
   *    If the chart is displayed incorrectly within a modal or tab,
   *    ensure that this method is invoked after the chart is shown
   *    to ensure proper rendering.
   *
   * @vegaVersion 1.32.0
   */
  async reRender() {
    this.reRenderTimer && clearTimeout(this.reRenderTimer);
    /* istanbul ignore next */
    this.reRenderTimer = setTimeout(() => {
      this.chart.reRender();
    }, 0);
  }
  render() {
    return sanitizeVegaComponent(h(Host, null), this.host);
  }
  /**
   * This function draws a line chart using the provided options and data source.
   *
   * @param {LineChartOptionsType} options - The options parameter is an object that contains various options for configuring and rendering a line chart.
   */
  updateChart(options) {
    if (!options)
      return;
    const { mode = 'svg', dataSource } = options, restOptions = __rest(options, ["mode", "dataSource"]);
    const mergedOptions = Object.assign(Object.assign({}, restOptions), { mode, container: this.host, dataSource: dataSource || [] });
    if (this.chart) {
      this.chart.updateOptions(mergedOptions);
    }
    else {
      this.chart = new LineChart(mergedOptions);
      this.chart.render();
    }
  }
  get host() { return getElement(this); }
  static get watchers() { return {
    "options": ["watchOptionsHandel"]
  }; }
};
__decorate([
  InjectVegaGlobalSlimmer()
], VegaLineChart.prototype, "globalSlimmers", void 0);
__decorate([
  InjectVegaSlimmer()
], VegaLineChart.prototype, "vegaComponentUsageRuntimeMetricsSlimmer", void 0);
VegaLineChart.style = vegaLineChartCss;

export { VegaLineChart as vega_line_chart };
