/*!
 * Copyright © 2024 Splunk Inc.
 * SPLUNK CONFIDENTIAL – Use or disclosure of this material in whole or
 * in part without a valid written license from Splunk Inc. is PROHIBITED.
 */
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 16);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */,
/* 1 */,
/* 2 */
/***/ (function(module, exports) {

module.exports = require("@splunk/visualizations-shared/numberUtils");

/***/ }),
/* 3 */,
/* 4 */,
/* 5 */,
/* 6 */,
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.VizBehavior = void 0;
var VizBehavior;

(function (VizBehavior) {
  /**
   * Dynamic Options Behavior.
   * This allows visualization options to be powered by data
   *
   * **Example**
   *
   * sparklineValues: ">primary|seriesByIndex(0)"
   * would configure sparklineValues with an array of data points
   * coming from the first series in the primary datasource
   *
   */
  VizBehavior["DYNAMIC_OPTIONS"] = "dynamic-options";
  VizBehavior["EVENTS"] = "events";
  VizBehavior["DOWNSAMPLING"] = "downsampling";
  /**
   * Placeholder behavior: visualization will display a placeholder rather than fail if any of the `requiredProps` is
   * missing.
   * @type {string}
   */

  VizBehavior["PLACEHOLDER"] = "placeholder";
  VizBehavior["PAGE_AND_SORT"] = "page-and-sort";
  VizBehavior["TRELLIS"] = "trellis";
})(VizBehavior = exports.VizBehavior || (exports.VizBehavior = {}));

/***/ }),
/* 8 */,
/* 9 */,
/* 10 */,
/* 11 */,
/* 12 */,
/* 13 */,
/* 14 */,
/* 15 */,
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.downsampleDataSources = exports.calculateDownsamplingThreshold = exports.calculateThresholdOnRangeSelect = exports.isDownsamplingEnabledForViz = exports.convertToArrOfObjects = void 0;

var numberUtils_1 = __webpack_require__(2);

var interfaces_1 = __webpack_require__(17); // TODO: utilize this fn in ParallelCoordinates


var convertToArrOfObjects = function convertToArrOfObjects(columns, fields) {
  if (!columns || !columns[0] || !columns[0].length) return [];
  var data = [];

  var _loop = function _loop(i) {
    var newObj = {};
    fields.forEach(function (field, index) {
      var fieldName = typeof field === 'string' ? field : field.name;

      if (columns[index][i] === '') {
        newObj[fieldName] = null;
      } else {
        newObj[fieldName] = columns[index][i];
      }
    });
    data.push(newObj);
  };

  for (var i = 0; i < columns[0].length; i += 1) {
    _loop(i);
  }

  return data;
};

exports.convertToArrOfObjects = convertToArrOfObjects; // LTTB algorithm which can be used to downsample time series data while striving to maintain
// the spikes and overall shape of the chart
// Copied from https://github.com/sveinn-steinarsson/flot-downsample/blob/0815010016fc94b1bbc6a010afb8aad13ada6d0d/jquery.flot.downsample.js
// Modifications include:
// 1) Convert to modern JavaScript(use const, let, and use array.push to push to last element of array)
// 2) Convert to camel case
// 3) Convert to TS and also return the indices of the points that are in the downsampled result.
// 4) Add a new parameter preferredDownsampleIndices that correspond to the indices of points
// that should be used in case of a tie of the max area in a bucket

var largestTriangleThreeBuckets = function largestTriangleThreeBuckets(data, threshold, preferredDownsampleIndices) {
  var dataLength = data.length;
  var downsampledIndices = [];

  if (threshold >= dataLength || threshold === 0) {
    var allIndices = data.map(function (values, index) {
      return index;
    });
    return {
      downsampledData: data,
      downsampledIndices: allIndices
    }; // Nothing to do
  }

  var sampled = [];
  var sampledIndex = 0; // Bucket size. Leave room for start and end data points

  var every = (dataLength - 2) / (threshold - 2);
  var a = 0; // Initially a is the first point in the triangle

  var maxAreaPoint;
  var maxArea;
  var area;
  var nextA;
  sampled.push(data[a]); // Always add the first point

  downsampledIndices.push(0); // eslint-disable-next-line no-plusplus

  for (var i = 0; i < threshold - 2; i++) {
    // Calculate point average for next bucket (containing c)
    var avgX = 0;
    var avgY = 0;
    var avgRangeStart = Math.floor((i + 1) * every) + 1;
    var avgRangeEnd = Math.floor((i + 2) * every) + 1;
    avgRangeEnd = avgRangeEnd < dataLength ? avgRangeEnd : dataLength;
    var avgRangeLength = avgRangeEnd - avgRangeStart; // eslint-disable-next-line no-plusplus

    for (; avgRangeStart < avgRangeEnd; avgRangeStart++) {
      avgX += Number(data[avgRangeStart][0]); // * 1 enforces Number (value may be Date)

      avgY += data[avgRangeStart][1] * 1;
    }

    avgX /= avgRangeLength;
    avgY /= avgRangeLength; // Get the range for this bucket

    var rangeOffs = Math.floor((i + 0) * every) + 1;
    var rangeTo = Math.floor((i + 1) * every) + 1; // Point a

    var pointAX = Number(data[a][0]); // Enforce Number (value may be Date)

    var pointAY = data[a][1] * 1; // eslint-disable-next-line no-multi-assign

    maxArea = area = -1;
    var maxAreaIndex = rangeOffs; // eslint-disable-next-line no-plusplus

    for (; rangeOffs < rangeTo; rangeOffs++) {
      // Calculate triangle area over three buckets
      area = Math.abs((pointAX - avgX) * (data[rangeOffs][1] - pointAY) - (pointAX - Number(data[rangeOffs][0])) * (avgY - pointAY)) * 0.5; // Modification: try to downsample the least amount of points possible when there are multiple series
      // If all points in a bucket have the same area, prioritize the one with an x index
      // that also existed from another series so we don't add another point unnecessarily.
      // By default LTTB picks the leftmost point in the bucket

      if (area > maxArea || area === maxArea && preferredDownsampleIndices.has(rangeOffs)) {
        maxArea = area;
        maxAreaPoint = data[rangeOffs];
        nextA = rangeOffs; // Next a is this b
        // Modification: save the index of the point with the most area

        maxAreaIndex = rangeOffs;
      }
    } // eslint-disable-next-line no-plusplus


    sampled[sampledIndex++] = maxAreaPoint; // Pick this point from the bucket

    downsampledIndices.push(maxAreaIndex);
    a = nextA; // This a is the next a (chosen b)
  } // eslint-disable-next-line no-plusplus


  sampled[sampledIndex++] = data[dataLength - 1]; // Always add last

  downsampledIndices.push(dataLength - 1);
  return {
    downsampledData: sampled,
    downsampledIndices: downsampledIndices
  };
};
/**
 * Strictly coerces the entire column to numbers if it only consists of numeric strings or numbers. Also determines
 * if at least one of the values in the column can be loosely coerced to a number.
 * If the column cannot be strictly downsampled (if it contains nulls or non-numeric strings), returns an empty array and
 * returns that it cannot downsample the column.
 */


var strictlyCoerceYColumn = function strictlyCoerceYColumn(column) {
  // Splunk charting allows for numbers in formats such as negative hex that
  // Number() does not support and also allows loose coercion of hex numbers (but not other formats)
  // We want to identify columns which contain at least one value that can be loosely coerced
  var canLooselyCoerceSomeValues = column.findIndex(function (value) {
    return (0, numberUtils_1.startsWithNumber)("".concat(value));
  }) >= 0; // If not all values in column can be strictly coerced to a number, we do not downsample

  var coercedColumn = [];
  var canDownsampleColumn = !column.some(function (value) {
    var coercedValue = Number(value); // if it can't be parsed or isn't safe, fail

    if (Number.isNaN(coercedValue) || coercedValue <= Number.MIN_SAFE_INTEGER || coercedValue >= Number.MAX_SAFE_INTEGER || typeof value !== 'string' && typeof value !== 'number') {
      return true;
    } // save value and continue to next


    coercedColumn.push(coercedValue);
    return false;
  });
  return {
    canDownsampleColumn: canDownsampleColumn,
    canLooselyCoerceSomeValues: canLooselyCoerceSomeValues,
    coercedColumn: canDownsampleColumn ? coercedColumn : []
  };
};
/**
 * Tries to coerce the x-column to numbers or dates, if it is eligible for downsampling.
 * Only strictly increasing x-columns are eligible for downsampling.
 * If the column is not eligible for downsampling, returns an empty array.
 */


var strictlyCoerceXColumn = function strictlyCoerceXColumn(column, fieldType) {
  if (fieldType === 'number') {
    var coercedXColumn = column.map(function (xValue) {
      return Number(xValue);
    });

    if (isColumnStrictlyIncreasing(coercedXColumn, fieldType)) {
      return coercedXColumn;
    }
  } else if (fieldType === 'time') {
    var _coercedXColumn = column.map(function (xValue) {
      return new Date(xValue);
    });

    if (isColumnStrictlyIncreasing(_coercedXColumn, fieldType)) {
      return _coercedXColumn;
    }
  }

  return [];
};

var isDownsamplingEnabledForViz = function isDownsamplingEnabledForViz(_ref) {
  var vizConfig = _ref.vizConfig;

  var _a;

  return (_a = vizConfig.supports) === null || _a === void 0 ? void 0 : _a.includes(interfaces_1.VizBehavior.DOWNSAMPLING);
};

exports.isDownsamplingEnabledForViz = isDownsamplingEnabledForViz;

var calculateThresholdOnRangeSelect = function calculateThresholdOnRangeSelect(_ref2) {
  var firstIndex = _ref2.firstIndex,
      lastIndex = _ref2.lastIndex,
      dataSources = _ref2.dataSources,
      width = _ref2.width;

  var _a, _b, _c;

  var window = lastIndex - firstIndex + 1;
  var ratio = Math.round(Number(((_c = (_b = (_a = dataSources === null || dataSources === void 0 ? void 0 : dataSources.primary) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.columns[0]) === null || _c === void 0 ? void 0 : _c.length) / window) * 10) / 10;
  return Math.round(ratio * Number(width));
};

exports.calculateThresholdOnRangeSelect = calculateThresholdOnRangeSelect;
/**
 * Calculates the downsampling threshold based on the range selection. If search zoom is enabled or there is no selection,
 * then returns the width of the visualization.
 *
 * Otherwise calculates the threshold based on the ratio of the window selected compared to the size of the non-downsampled
 * data sources. Returns null if the chart event's dataset does not match the passed in primary data source or if the chart is zoomed
 * in for a categorical chart.
 */

var calculateDownsamplingThreshold = function calculateDownsamplingThreshold(_ref3) {
  var enableSearchZoom = _ref3.enableSearchZoom,
      dataSources = _ref3.dataSources,
      selectChartEvent = _ref3.selectChartEvent,
      width = _ref3.width,
      xField = _ref3.xField,
      y2Fields = _ref3.y2Fields;

  var _a, _b, _c;

  if (enableSearchZoom || !selectChartEvent) {
    return Number(width);
  }

  var primaryDataSource = dataSources === null || dataSources === void 0 ? void 0 : dataSources.primary;

  if (!primaryDataSource) {
    return null;
  }

  var startXIndex = selectChartEvent.startXIndex,
      endXIndex = selectChartEvent.endXIndex,
      currentTarget = selectChartEvent.currentTarget;

  try {
    var xFieldIndex = (_a = primaryDataSource === null || primaryDataSource === void 0 ? void 0 : primaryDataSource.data) === null || _a === void 0 ? void 0 : _a.fields.findIndex(function (field) {
      return field.name === xField;
    });
    var downsampledXFieldIndex = (_b = currentTarget.dataSet) === null || _b === void 0 ? void 0 : _b.fields.findIndex(function (field) {
      return field === xField;
    });

    if (xFieldIndex === -1 || downsampledXFieldIndex === -1) {
      return null;
    }

    var fullSeries = (_c = primaryDataSource === null || primaryDataSource === void 0 ? void 0 : primaryDataSource.data) === null || _c === void 0 ? void 0 : _c.columns[xFieldIndex];
    var downsampledSeries = currentTarget.dataSet.seriesList[downsampledXFieldIndex];
    var firstIndex = fullSeries.findIndex(function (x) {
      return downsampledSeries[startXIndex] === x;
    });
    var lastIndex = fullSeries.findIndex(function (x) {
      return downsampledSeries[endXIndex] === x;
    }); // For charts with categorical x-axis (charts with an xField that isn't _time), do not support
    // re-calculating downsampling threshold if the chart is zoomed in until SPL-259458 is fixed
    // Also do not support re-calculating downsampling threshold for zoomed-in charts with y2
    // until SPL-259611 is fixed

    if (xField !== '_time' || (y2Fields === null || y2Fields === void 0 ? void 0 : y2Fields.length)) {
      return firstIndex === 0 && lastIndex === fullSeries.length - 1 ? width : null;
    }

    if (firstIndex >= 0 && lastIndex >= 0 && firstIndex <= lastIndex) {
      return (0, exports.calculateThresholdOnRangeSelect)({
        firstIndex: firstIndex,
        lastIndex: lastIndex,
        dataSources: dataSources,
        width: width
      });
    }
  } catch (e) {
    console.error('Error occurred while setting downsample threshold on range select event', e);
  }

  return null;
};

exports.calculateDownsamplingThreshold = calculateDownsamplingThreshold;

var isColumnStrictlyIncreasing = function isColumnStrictlyIncreasing(column, fieldType) {
  return column.every(function (value, index) {
    if (fieldType === 'number') {
      if (Number.isNaN(value)) {
        return false;
      }
    }

    if (fieldType === 'time') {
      if (Number.isNaN(value.getTime())) {
        return false;
      }
    }

    if (index === 0) {
      return true;
    }

    return value > column[index - 1];
  });
};
/**
 * Verifies that all of the columns that are displayed in a chart can be downsampled. Valid columns that can be
 * displayed are those that contain at least one number. We can only downsample columns that only consist of numbers.
 *
 * If all columns can be downsampled, returns the x column coerced to time/number and y columns coerced to numbers.
 * If not all columns can be downsampled, then returns empty arrays for both x and y
 */


var tryToCoerceAllDisplayedFields = function tryToCoerceAllDisplayedFields(ds, xField, yFields, fieldTypes) {
  var xColumn = [];
  var yColumns = [];
  var canDownsample = !ds.data.fields.some(function (field, index) {
    var _a, _b;

    var fieldName = (_a = field.name) !== null && _a !== void 0 ? _a : field;
    var fieldType = (_b = fieldTypes[index]) !== null && _b !== void 0 ? _b : 'unknown';
    var column = ds.data.columns[index];
    var hasDisplayedColumnThatCantBeDownsampled = false;

    if (fieldName === xField) {
      xColumn = strictlyCoerceXColumn(column, fieldType);
    } else if (yFields.has(fieldName)) {
      var _strictlyCoerceYColum = strictlyCoerceYColumn(ds.data.columns[index]),
          coercedColumn = _strictlyCoerceYColum.coercedColumn,
          canLooselyCoerceSomeValues = _strictlyCoerceYColum.canLooselyCoerceSomeValues,
          canDownsampleColumn = _strictlyCoerceYColum.canDownsampleColumn; // do not perform downsampling if a column can possibly be displayed but cannot
      // be downsampled using LTTB


      hasDisplayedColumnThatCantBeDownsampled = canLooselyCoerceSomeValues && !canDownsampleColumn;

      if (hasDisplayedColumnThatCantBeDownsampled) {
        return true;
      }

      if (canDownsampleColumn) {
        yColumns.push(coercedColumn);
      }
    }

    return false;
  });

  if (canDownsample) {
    return {
      xColumn: xColumn,
      yColumns: yColumns
    };
  }

  return {
    xColumn: [],
    yColumns: []
  };
};

var pickIndicesFromDataSource = function pickIndicesFromDataSource(ds, indices) {
  var sortedIndices = Array.from(indices).sort(function (a, b) {
    return a - b;
  });
  var slicedColumns = [];
  ds.data.columns.forEach(function (column) {
    var slicedColumn = [];
    sortedIndices.forEach(function (index) {
      slicedColumn.push(column[index]);
    });
    slicedColumns.push(slicedColumn);
  }); // update data columns with downsampled columns

  return Object.assign(Object.assign({}, ds), {
    data: Object.assign(Object.assign({}, ds.data), {
      columns: slicedColumns
    })
  });
};

var downsampleDataSources = function downsampleDataSources(_ref4) {
  var dataSources = _ref4.dataSources,
      threshold = _ref4.threshold,
      options = _ref4.options;

  var _a, _b, _c;

  var primaryDS = dataSources === null || dataSources === void 0 ? void 0 : dataSources.primary; // only downsample time series when number of data points are over threshold

  var numPoints = (_c = (_b = (_a = primaryDS === null || primaryDS === void 0 ? void 0 : primaryDS.data) === null || _a === void 0 ? void 0 : _a.columns[0]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;

  if (Number.isNaN(threshold) || numPoints <= threshold || threshold < 2) {
    return dataSources;
  }

  var xField = options.xField,
      yFields = options.yFields,
      fieldTypes = options.fieldTypes;

  if (!xField || !(yFields === null || yFields === void 0 ? void 0 : yFields.length) || !(fieldTypes === null || fieldTypes === void 0 ? void 0 : fieldTypes.length)) {
    return dataSources;
  }

  var nonInternalYFields = new Set(yFields.filter(function (yField) {
    return !yField.startsWith('_');
  }));
  var maxPointsInDownsample = Math.min(nonInternalYFields.size * threshold, numPoints); // Do not try to downsample if there are too many downsampled pts
  // At the worst case, each series has non-overlapping downsampled pts
  // which will mean that all points will be included in the downsampled result
  // This will just lead to additional overhead due to coercing each
  // x and y field to number

  if (maxPointsInDownsample >= numPoints) {
    return dataSources;
  }

  var _tryToCoerceAllDispla = tryToCoerceAllDisplayedFields(primaryDS, xField, nonInternalYFields, fieldTypes),
      xColumn = _tryToCoerceAllDispla.xColumn,
      yColumns = _tryToCoerceAllDispla.yColumns;

  if (!yColumns.length || !xColumn.length) {
    return dataSources;
  }

  var downsampledDataSources = Object.assign({}, dataSources);
  var downsampledIndices = new Set();
  yColumns.forEach(function (yColumn, columnIndex) {
    // perform LTTB downsampling for current series, LTTB takes an [x, y] pair
    var xyPair = yColumn.map(function (yValue, index) {
      return [xColumn[index], yValue];
    });

    try {
      var _largestTriangleThree = largestTriangleThreeBuckets(xyPair, threshold, downsampledIndices),
          downsampledIndicesForSeries = _largestTriangleThree.downsampledIndices;

      downsampledIndicesForSeries.forEach(function (downsampleIndex) {
        return downsampledIndices.add(downsampleIndex);
      });
    } catch (e) {
      console.error("Error occurred while downsampling column ".concat(columnIndex), e);
    }
  }); // update data columns with downsampled columns

  downsampledDataSources.primary = pickIndicesFromDataSource(primaryDS, downsampledIndices);
  return downsampledDataSources;
};

exports.downsampleDataSources = downsampleDataSources;

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
  if (k2 === undefined) k2 = k;
  var desc = Object.getOwnPropertyDescriptor(m, k);

  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
    desc = {
      enumerable: true,
      get: function get() {
        return m[k];
      }
    };
  }

  Object.defineProperty(o, k2, desc);
} : function (o, m, k, k2) {
  if (k2 === undefined) k2 = k;
  o[k2] = m[k];
});

var __exportStar = this && this.__exportStar || function (m, exports) {
  for (var p in m) {
    if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  }
};

Object.defineProperty(exports, "__esModule", {
  value: true
});

__exportStar(__webpack_require__(18), exports);

__exportStar(__webpack_require__(19), exports);

__exportStar(__webpack_require__(20), exports);

__exportStar(__webpack_require__(21), exports);

__exportStar(__webpack_require__(22), exports);

__exportStar(__webpack_require__(23), exports);

__exportStar(__webpack_require__(24), exports);

__exportStar(__webpack_require__(25), exports);

__exportStar(__webpack_require__(26), exports);

__exportStar(__webpack_require__(27), exports);

__exportStar(__webpack_require__(28), exports);

__exportStar(__webpack_require__(7), exports);

__exportStar(__webpack_require__(31), exports);

__exportStar(__webpack_require__(32), exports);

__exportStar(__webpack_require__(33), exports);

__exportStar(__webpack_require__(34), exports);

__exportStar(__webpack_require__(35), exports);

__exportStar(__webpack_require__(36), exports);

__exportStar(__webpack_require__(37), exports);

/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 *  A data structure used at runtime to wire up a visualization.
 */

Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.validOutputModes = exports.validSegmentationModes = exports.validSortDirs = void 0;
exports.validSortDirs = ['asc', 'desc', 'none'];
exports.validSegmentationModes = ['none', 'inner'];
exports.validOutputModes = ['json_cols', 'json'];

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var _classCallCheck = __webpack_require__(29);

var _createClass = __webpack_require__(30);

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DefaultVizActionHandler = void 0;

var DefaultVizActionHandler = /*#__PURE__*/function () {
  function DefaultVizActionHandler() {
    _classCallCheck(this, DefaultVizActionHandler);
  }

  _createClass(DefaultVizActionHandler, [{
    key: "focus",
    value: function focus() {// noop
    }
  }, {
    key: "snapshot",
    value: function snapshot() {
      return null; // noop
    }
  }]);

  return DefaultVizActionHandler;
}();

exports.DefaultVizActionHandler = DefaultVizActionHandler;

/***/ }),
/* 29 */
/***/ (function(module, exports) {

module.exports = require("@babel/runtime/helpers/classCallCheck");

/***/ }),
/* 30 */
/***/ (function(module, exports) {

module.exports = require("@babel/runtime/helpers/createClass");

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.VizCategory = void 0;
var VizCategory;

(function (VizCategory) {
  VizCategory["SINGLE_VALUE"] = "Single Value";
  VizCategory["TRENDS"] = "Trends";
  VizCategory["COMPARISONS"] = "Comparisons";
  VizCategory["TABLE"] = "Table";
  VizCategory["GAUGE"] = "Gauge";
  VizCategory["DISTRIBUTIONS"] = "Distributions";
  VizCategory["CHOROPLETH"] = "Choropleth Maps";
  VizCategory["SHAPES"] = "Shapes";
  VizCategory["MISC"] = "misc";
  VizCategory["FLOW"] = "Flow";
  VizCategory["CORRELATION"] = "Correlation";
  VizCategory["SPATIAL"] = "Spatial";
})(VizCategory = exports.VizCategory || (exports.VizCategory = {}));

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

/***/ })
/******/ ]);
//# sourceMappingURL=dataUtils.js.map