office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/data/helper/dataProvider.js

@@ -0,0 +1,321 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+var Source = require('../Source.js');
+var types = require('../../util/types.js');
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+var _a, _b, _c;
+var providerMethods;
+var mountMethods;
+/**
+ * If normal array used, mutable chunk size is supported.
+ * If typed array used, chunk size must be fixed.
+ */
+var DefaultDataProvider = /** @class */function () {
+  function DefaultDataProvider(sourceParam, dimSize) {
+    // let source: Source;
+    var source = !Source.isSourceInstance(sourceParam) ? Source.createSourceFromSeriesDataOption(sourceParam) : sourceParam;
+    // declare source is Source;
+    this._source = source;
+    var data = this._data = source.data;
+    // Typed array. TODO IE10+?
+    if (source.sourceFormat === types.SOURCE_FORMAT_TYPED_ARRAY) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (dimSize == null) {
+          throw new Error('Typed array data must specify dimension size');
+        }
+      }
+      this._offset = 0;
+      this._dimSize = dimSize;
+      this._data = data;
+    }
+    mountMethods(this, data, source);
+  }
+  DefaultDataProvider.prototype.getSource = function () {
+    return this._source;
+  };
+  DefaultDataProvider.prototype.count = function () {
+    return 0;
+  };
+  DefaultDataProvider.prototype.getItem = function (idx, out) {
+    return;
+  };
+  DefaultDataProvider.prototype.appendData = function (newData) {};
+  DefaultDataProvider.prototype.clean = function () {};
+  DefaultDataProvider.protoInitialize = function () {
+    // PENDING: To avoid potential incompat (e.g., prototype
+    // is visited somewhere), still init them on prototype.
+    var proto = DefaultDataProvider.prototype;
+    proto.pure = false;
+    proto.persistent = true;
+  }();
+  DefaultDataProvider.internalField = function () {
+    var _a;
+    mountMethods = function (provider, data, source) {
+      var sourceFormat = source.sourceFormat;
+      var seriesLayoutBy = source.seriesLayoutBy;
+      var startIndex = source.startIndex;
+      var dimsDef = source.dimensionsDefine;
+      var methods = providerMethods[getMethodMapKey(sourceFormat, seriesLayoutBy)];
+      if (process.env.NODE_ENV !== 'production') {
+        util.assert(methods, 'Invalide sourceFormat: ' + sourceFormat);
+      }
+      util.extend(provider, methods);
+      if (sourceFormat === types.SOURCE_FORMAT_TYPED_ARRAY) {
+        provider.getItem = getItemForTypedArray;
+        provider.count = countForTypedArray;
+        provider.fillStorage = fillStorageForTypedArray;
+      } else {
+        var rawItemGetter = getRawSourceItemGetter(sourceFormat, seriesLayoutBy);
+        provider.getItem = util.bind(rawItemGetter, null, data, startIndex, dimsDef);
+        var rawCounter = getRawSourceDataCounter(sourceFormat, seriesLayoutBy);
+        provider.count = util.bind(rawCounter, null, data, startIndex, dimsDef);
+      }
+    };
+    var getItemForTypedArray = function (idx, out) {
+      idx = idx - this._offset;
+      out = out || [];
+      var data = this._data;
+      var dimSize = this._dimSize;
+      var offset = dimSize * idx;
+      for (var i = 0; i < dimSize; i++) {
+        out[i] = data[offset + i];
+      }
+      return out;
+    };
+    var fillStorageForTypedArray = function (start, end, storage, extent) {
+      var data = this._data;
+      var dimSize = this._dimSize;
+      for (var dim = 0; dim < dimSize; dim++) {
+        var dimExtent = extent[dim];
+        var min = dimExtent[0] == null ? Infinity : dimExtent[0];
+        var max = dimExtent[1] == null ? -Infinity : dimExtent[1];
+        var count = end - start;
+        var arr = storage[dim];
+        for (var i = 0; i < count; i++) {
+          // appendData with TypedArray will always do replace in provider.
+          var val = data[i * dimSize + dim];
+          arr[start + i] = val;
+          val < min && (min = val);
+          val > max && (max = val);
+        }
+        dimExtent[0] = min;
+        dimExtent[1] = max;
+      }
+    };
+    var countForTypedArray = function () {
+      return this._data ? this._data.length / this._dimSize : 0;
+    };
+    providerMethods = (_a = {}, _a[types.SOURCE_FORMAT_ARRAY_ROWS + '_' + types.SERIES_LAYOUT_BY_COLUMN] = {
+      pure: true,
+      appendData: appendDataSimply
+    }, _a[types.SOURCE_FORMAT_ARRAY_ROWS + '_' + types.SERIES_LAYOUT_BY_ROW] = {
+      pure: true,
+      appendData: function () {
+        throw new Error('Do not support appendData when set seriesLayoutBy: "row".');
+      }
+    }, _a[types.SOURCE_FORMAT_OBJECT_ROWS] = {
+      pure: true,
+      appendData: appendDataSimply
+    }, _a[types.SOURCE_FORMAT_KEYED_COLUMNS] = {
+      pure: true,
+      appendData: function (newData) {
+        var data = this._data;
+        util.each(newData, function (newCol, key) {
+          var oldCol = data[key] || (data[key] = []);
+          for (var i = 0; i < (newCol || []).length; i++) {
+            oldCol.push(newCol[i]);
+          }
+        });
+      }
+    }, _a[types.SOURCE_FORMAT_ORIGINAL] = {
+      appendData: appendDataSimply
+    }, _a[types.SOURCE_FORMAT_TYPED_ARRAY] = {
+      persistent: false,
+      pure: true,
+      appendData: function (newData) {
+        if (process.env.NODE_ENV !== 'production') {
+          util.assert(util.isTypedArray(newData), 'Added data must be TypedArray if data in initialization is TypedArray');
+        }
+        this._data = newData;
+      },
+      // Clean self if data is already used.
+      clean: function () {
+        // PENDING
+        this._offset += this.count();
+        this._data = null;
+      }
+    }, _a);
+    function appendDataSimply(newData) {
+      for (var i = 0; i < newData.length; i++) {
+        this._data.push(newData[i]);
+      }
+    }
+  }();
+  return DefaultDataProvider;
+}();
+var getItemSimply = function (rawData, startIndex, dimsDef, idx) {
+  return rawData[idx];
+};
+var rawSourceItemGetterMap = (_a = {}, _a[types.SOURCE_FORMAT_ARRAY_ROWS + '_' + types.SERIES_LAYOUT_BY_COLUMN] = function (rawData, startIndex, dimsDef, idx) {
+  return rawData[idx + startIndex];
+}, _a[types.SOURCE_FORMAT_ARRAY_ROWS + '_' + types.SERIES_LAYOUT_BY_ROW] = function (rawData, startIndex, dimsDef, idx, out) {
+  idx += startIndex;
+  var item = out || [];
+  var data = rawData;
+  for (var i = 0; i < data.length; i++) {
+    var row = data[i];
+    item[i] = row ? row[idx] : null;
+  }
+  return item;
+}, _a[types.SOURCE_FORMAT_OBJECT_ROWS] = getItemSimply, _a[types.SOURCE_FORMAT_KEYED_COLUMNS] = function (rawData, startIndex, dimsDef, idx, out) {
+  var item = out || [];
+  for (var i = 0; i < dimsDef.length; i++) {
+    var dimName = dimsDef[i].name;
+    if (process.env.NODE_ENV !== 'production') {
+      if (dimName == null) {
+        throw new Error();
+      }
+    }
+    var col = rawData[dimName];
+    item[i] = col ? col[idx] : null;
+  }
+  return item;
+}, _a[types.SOURCE_FORMAT_ORIGINAL] = getItemSimply, _a);
+function getRawSourceItemGetter(sourceFormat, seriesLayoutBy) {
+  var method = rawSourceItemGetterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)];
+  if (process.env.NODE_ENV !== 'production') {
+    util.assert(method, 'Do not support get item on "' + sourceFormat + '", "' + seriesLayoutBy + '".');
+  }
+  return method;
+}
+var countSimply = function (rawData, startIndex, dimsDef) {
+  return rawData.length;
+};
+var rawSourceDataCounterMap = (_b = {}, _b[types.SOURCE_FORMAT_ARRAY_ROWS + '_' + types.SERIES_LAYOUT_BY_COLUMN] = function (rawData, startIndex, dimsDef) {
+  return Math.max(0, rawData.length - startIndex);
+}, _b[types.SOURCE_FORMAT_ARRAY_ROWS + '_' + types.SERIES_LAYOUT_BY_ROW] = function (rawData, startIndex, dimsDef) {
+  var row = rawData[0];
+  return row ? Math.max(0, row.length - startIndex) : 0;
+}, _b[types.SOURCE_FORMAT_OBJECT_ROWS] = countSimply, _b[types.SOURCE_FORMAT_KEYED_COLUMNS] = function (rawData, startIndex, dimsDef) {
+  var dimName = dimsDef[0].name;
+  if (process.env.NODE_ENV !== 'production') {
+    if (dimName == null) {
+      throw new Error();
+    }
+  }
+  var col = rawData[dimName];
+  return col ? col.length : 0;
+}, _b[types.SOURCE_FORMAT_ORIGINAL] = countSimply, _b);
+function getRawSourceDataCounter(sourceFormat, seriesLayoutBy) {
+  var method = rawSourceDataCounterMap[getMethodMapKey(sourceFormat, seriesLayoutBy)];
+  if (process.env.NODE_ENV !== 'production') {
+    util.assert(method, 'Do not support count on "' + sourceFormat + '", "' + seriesLayoutBy + '".');
+  }
+  return method;
+}
+var getRawValueSimply = function (dataItem, dimIndex, property) {
+  return dataItem[dimIndex];
+};
+var rawSourceValueGetterMap = (_c = {}, _c[types.SOURCE_FORMAT_ARRAY_ROWS] = getRawValueSimply, _c[types.SOURCE_FORMAT_OBJECT_ROWS] = function (dataItem, dimIndex, property) {
+  return dataItem[property];
+}, _c[types.SOURCE_FORMAT_KEYED_COLUMNS] = getRawValueSimply, _c[types.SOURCE_FORMAT_ORIGINAL] = function (dataItem, dimIndex, property) {
+  // FIXME: In some case (markpoint in geo (geo-map.html)),
+  // dataItem is {coord: [...]}
+  var value = model.getDataItemValue(dataItem);
+  return !(value instanceof Array) ? value : value[dimIndex];
+}, _c[types.SOURCE_FORMAT_TYPED_ARRAY] = getRawValueSimply, _c);
+function getRawSourceValueGetter(sourceFormat) {
+  var method = rawSourceValueGetterMap[sourceFormat];
+  if (process.env.NODE_ENV !== 'production') {
+    util.assert(method, 'Do not support get value on "' + sourceFormat + '".');
+  }
+  return method;
+}
+function getMethodMapKey(sourceFormat, seriesLayoutBy) {
+  return sourceFormat === types.SOURCE_FORMAT_ARRAY_ROWS ? sourceFormat + '_' + seriesLayoutBy : sourceFormat;
+}
+// ??? FIXME can these logic be more neat: getRawValue, getRawDataItem,
+// Consider persistent.
+// Caution: why use raw value to display on label or tooltip?
+// A reason is to avoid format. For example time value we do not know
+// how to format is expected. More over, if stack is used, calculated
+// value may be 0.91000000001, which have brings trouble to display.
+// TODO: consider how to treat null/undefined/NaN when display?
+function retrieveRawValue(data, dataIndex,
+// If dimIndex is null/undefined, return OptionDataItem.
+// Otherwise, return OptionDataValue.
+dim) {
+  if (!data) {
+    return;
+  }
+  // Consider data may be not persistent.
+  var dataItem = data.getRawDataItem(dataIndex);
+  if (dataItem == null) {
+    return;
+  }
+  var store = data.getStore();
+  var sourceFormat = store.getSource().sourceFormat;
+  if (dim != null) {
+    var dimIndex = data.getDimensionIndex(dim);
+    var property = store.getDimensionProperty(dimIndex);
+    return getRawSourceValueGetter(sourceFormat)(dataItem, dimIndex, property);
+  } else {
+    var result = dataItem;
+    if (sourceFormat === types.SOURCE_FORMAT_ORIGINAL) {
+      result = model.getDataItemValue(dataItem);
+    }
+    return result;
+  }
+}
+
+exports.DefaultDataProvider = DefaultDataProvider;
+exports.getRawSourceDataCounter = getRawSourceDataCounter;
+exports.getRawSourceItemGetter = getRawSourceItemGetter;
+exports.getRawSourceValueGetter = getRawSourceValueGetter;
+exports.retrieveRawValue = retrieveRawValue;

package/lib/node_modules/echarts/lib/data/helper/dataStackHelper.js

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var SeriesDataSchema = require('./SeriesDataSchema.js');
+
+/**
+ * Note that it is too complicated to support 3d stack by value
+ * (have to create two-dimension inverted index), so in 3d case
+ * we just support that stacked by index.
+ *
+ * @param seriesModel
+ * @param dimensionsInput The same as the input of <module:echarts/data/SeriesData>.
+ *        The input will be modified.
+ * @param opt
+ * @param opt.stackedCoordDimension Specify a coord dimension if needed.
+ * @param opt.byIndex=false
+ * @return calculationInfo
+ * {
+ *     stackedDimension: string
+ *     stackedByDimension: string
+ *     isStackedByIndex: boolean
+ *     stackedOverDimension: string
+ *     stackResultDimension: string
+ * }
+ */
+function enableDataStack(seriesModel, dimensionsInput, opt) {
+  opt = opt || {};
+  var byIndex = opt.byIndex;
+  var stackedCoordDimension = opt.stackedCoordDimension;
+  var dimensionDefineList;
+  var schema;
+  var store;
+  if (isLegacyDimensionsInput(dimensionsInput)) {
+    dimensionDefineList = dimensionsInput;
+  } else {
+    schema = dimensionsInput.schema;
+    dimensionDefineList = schema.dimensions;
+    store = dimensionsInput.store;
+  }
+  // Compatibal: when `stack` is set as '', do not stack.
+  var mayStack = !!(seriesModel && seriesModel.get('stack'));
+  var stackedByDimInfo;
+  var stackedDimInfo;
+  var stackResultDimension;
+  var stackedOverDimension;
+  util.each(dimensionDefineList, function (dimensionInfo, index) {
+    if (util.isString(dimensionInfo)) {
+      dimensionDefineList[index] = dimensionInfo = {
+        name: dimensionInfo
+      };
+    }
+    if (mayStack && !dimensionInfo.isExtraCoord) {
+      // Find the first ordinal dimension as the stackedByDimInfo.
+      if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) {
+        stackedByDimInfo = dimensionInfo;
+      }
+      // Find the first stackable dimension as the stackedDimInfo.
+      if (!stackedDimInfo && dimensionInfo.type !== 'ordinal' && dimensionInfo.type !== 'time' && (!stackedCoordDimension || stackedCoordDimension === dimensionInfo.coordDim)) {
+        stackedDimInfo = dimensionInfo;
+      }
+    }
+  });
+  if (stackedDimInfo && !byIndex && !stackedByDimInfo) {
+    // Compatible with previous design, value axis (time axis) only stack by index.
+    // It may make sense if the user provides elaborately constructed data.
+    byIndex = true;
+  }
+  // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`.
+  // That put stack logic in List is for using conveniently in echarts extensions, but it
+  // might not be a good way.
+  if (stackedDimInfo) {
+    // Use a weird name that not duplicated with other names.
+    // Also need to use seriesModel.id as postfix because different
+    // series may share same data store. The stack dimension needs to be distinguished.
+    stackResultDimension = '__\0ecstackresult_' + seriesModel.id;
+    stackedOverDimension = '__\0ecstackedover_' + seriesModel.id;
+    // Create inverted index to fast query index by value.
+    if (stackedByDimInfo) {
+      stackedByDimInfo.createInvertedIndices = true;
+    }
+    var stackedDimCoordDim_1 = stackedDimInfo.coordDim;
+    var stackedDimType = stackedDimInfo.type;
+    var stackedDimCoordIndex_1 = 0;
+    util.each(dimensionDefineList, function (dimensionInfo) {
+      if (dimensionInfo.coordDim === stackedDimCoordDim_1) {
+        stackedDimCoordIndex_1++;
+      }
+    });
+    var stackedOverDimensionDefine = {
+      name: stackResultDimension,
+      coordDim: stackedDimCoordDim_1,
+      coordDimIndex: stackedDimCoordIndex_1,
+      type: stackedDimType,
+      isExtraCoord: true,
+      isCalculationCoord: true,
+      storeDimIndex: dimensionDefineList.length
+    };
+    var stackResultDimensionDefine = {
+      name: stackedOverDimension,
+      // This dimension contains stack base (generally, 0), so do not set it as
+      // `stackedDimCoordDim` to avoid extent calculation, consider log scale.
+      coordDim: stackedOverDimension,
+      coordDimIndex: stackedDimCoordIndex_1 + 1,
+      type: stackedDimType,
+      isExtraCoord: true,
+      isCalculationCoord: true,
+      storeDimIndex: dimensionDefineList.length + 1
+    };
+    if (schema) {
+      if (store) {
+        stackedOverDimensionDefine.storeDimIndex = store.ensureCalculationDimension(stackedOverDimension, stackedDimType);
+        stackResultDimensionDefine.storeDimIndex = store.ensureCalculationDimension(stackResultDimension, stackedDimType);
+      }
+      schema.appendCalculationDimension(stackedOverDimensionDefine);
+      schema.appendCalculationDimension(stackResultDimensionDefine);
+    } else {
+      dimensionDefineList.push(stackedOverDimensionDefine);
+      dimensionDefineList.push(stackResultDimensionDefine);
+    }
+  }
+  return {
+    stackedDimension: stackedDimInfo && stackedDimInfo.name,
+    stackedByDimension: stackedByDimInfo && stackedByDimInfo.name,
+    isStackedByIndex: byIndex,
+    stackedOverDimension: stackedOverDimension,
+    stackResultDimension: stackResultDimension
+  };
+}
+function isLegacyDimensionsInput(dimensionsInput) {
+  return !SeriesDataSchema.isSeriesDataSchema(dimensionsInput.schema);
+}
+function isDimensionStacked(data, stackedDim) {
+  // Each single series only maps to one pair of axis. So we do not need to
+  // check stackByDim, whatever stacked by a dimension or stacked by index.
+  return !!stackedDim && stackedDim === data.getCalculationInfo('stackedDimension');
+}
+function getStackedDimension(data, targetDim) {
+  return isDimensionStacked(data, targetDim) ? data.getCalculationInfo('stackResultDimension') : targetDim;
+}
+
+exports.enableDataStack = enableDataStack;
+exports.getStackedDimension = getStackedDimension;
+exports.isDimensionStacked = isDimensionStacked;

package/lib/node_modules/echarts/lib/data/helper/dataValueHelper.js

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var number = require('../../util/number.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var log = require('../../util/log.js');
+
+/**
+ * Convert raw the value in to inner value in List.
+ *
+ * [Performance sensitive]
+ *
+ * [Caution]: this is the key logic of user value parser.
+ * For backward compatibility, do not modify it until you have to!
+ */
+function parseDataValue(value,
+// For high performance, do not omit the second param.
+opt) {
+  // Performance sensitive.
+  var dimType = opt && opt.type;
+  if (dimType === 'ordinal') {
+    // If given value is a category string
+    return value;
+  }
+  if (dimType === 'time'
+  // spead up when using timestamp
+  && !util.isNumber(value) && value != null && value !== '-') {
+    value = +number.parseDate(value);
+  }
+  // dimType defaults 'number'.
+  // If dimType is not ordinal and value is null or undefined or NaN or '-',
+  // parse to NaN.
+  // number-like string (like ' 123 ') can be converted to a number.
+  // where null/undefined or other string will be converted to NaN.
+  return value == null || value === '' ? NaN
+  // If string (like '-'), using '+' parse to NaN
+  // If object, also parse to NaN
+  : +value;
+}
+var valueParserMap = util.createHashMap({
+  'number': function (val) {
+    // Do not use `numericToNumber` here. We have `numericToNumber` by default.
+    // Here the number parser can have loose rule:
+    // enable to cut suffix: "120px" => 120, "14%" => 14.
+    return parseFloat(val);
+  },
+  'time': function (val) {
+    // return timestamp.
+    return +number.parseDate(val);
+  },
+  'trim': function (val) {
+    return util.isString(val) ? util.trim(val) : val;
+  }
+});
+function getRawValueParser(type) {
+  return valueParserMap.get(type);
+}
+var ORDER_COMPARISON_OP_MAP = {
+  lt: function (lval, rval) {
+    return lval < rval;
+  },
+  lte: function (lval, rval) {
+    return lval <= rval;
+  },
+  gt: function (lval, rval) {
+    return lval > rval;
+  },
+  gte: function (lval, rval) {
+    return lval >= rval;
+  }
+};
+var FilterOrderComparator = /** @class */function () {
+  function FilterOrderComparator(op, rval) {
+    if (!util.isNumber(rval)) {
+      var errMsg = '';
+      if (process.env.NODE_ENV !== 'production') {
+        errMsg = 'rvalue of "<", ">", "<=", ">=" can only be number in filter.';
+      }
+      log.throwError(errMsg);
+    }
+    this._opFn = ORDER_COMPARISON_OP_MAP[op];
+    this._rvalFloat = number.numericToNumber(rval);
+  }
+  // Performance sensitive.
+  FilterOrderComparator.prototype.evaluate = function (lval) {
+    // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
+    return util.isNumber(lval) ? this._opFn(lval, this._rvalFloat) : this._opFn(number.numericToNumber(lval), this._rvalFloat);
+  };
+  return FilterOrderComparator;
+}();
+var SortOrderComparator = /** @class */function () {
+  /**
+   * @param order by default: 'asc'
+   * @param incomparable by default: Always on the tail.
+   *        That is, if 'asc' => 'max', if 'desc' => 'min'
+   *        See the definition of "incomparable" in [SORT_COMPARISON_RULE].
+   */
+  function SortOrderComparator(order, incomparable) {
+    var isDesc = order === 'desc';
+    this._resultLT = isDesc ? 1 : -1;
+    if (incomparable == null) {
+      incomparable = isDesc ? 'min' : 'max';
+    }
+    this._incomparable = incomparable === 'min' ? -Infinity : Infinity;
+  }
+  // See [SORT_COMPARISON_RULE].
+  // Performance sensitive.
+  SortOrderComparator.prototype.evaluate = function (lval, rval) {
+    // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
+    var lvalFloat = util.isNumber(lval) ? lval : number.numericToNumber(lval);
+    var rvalFloat = util.isNumber(rval) ? rval : number.numericToNumber(rval);
+    var lvalNotNumeric = isNaN(lvalFloat);
+    var rvalNotNumeric = isNaN(rvalFloat);
+    if (lvalNotNumeric) {
+      lvalFloat = this._incomparable;
+    }
+    if (rvalNotNumeric) {
+      rvalFloat = this._incomparable;
+    }
+    if (lvalNotNumeric && rvalNotNumeric) {
+      var lvalIsStr = util.isString(lval);
+      var rvalIsStr = util.isString(rval);
+      if (lvalIsStr) {
+        lvalFloat = rvalIsStr ? lval : 0;
+      }
+      if (rvalIsStr) {
+        rvalFloat = lvalIsStr ? rval : 0;
+      }
+    }
+    return lvalFloat < rvalFloat ? this._resultLT : lvalFloat > rvalFloat ? -this._resultLT : 0;
+  };
+  return SortOrderComparator;
+}();
+var FilterEqualityComparator = /** @class */function () {
+  function FilterEqualityComparator(isEq, rval) {
+    this._rval = rval;
+    this._isEQ = isEq;
+    this._rvalTypeof = typeof rval;
+    this._rvalFloat = number.numericToNumber(rval);
+  }
+  // Performance sensitive.
+  FilterEqualityComparator.prototype.evaluate = function (lval) {
+    var eqResult = lval === this._rval;
+    if (!eqResult) {
+      var lvalTypeof = typeof lval;
+      if (lvalTypeof !== this._rvalTypeof && (lvalTypeof === 'number' || this._rvalTypeof === 'number')) {
+        eqResult = number.numericToNumber(lval) === this._rvalFloat;
+      }
+    }
+    return this._isEQ ? eqResult : !eqResult;
+  };
+  return FilterEqualityComparator;
+}();
+/**
+ * [FILTER_COMPARISON_RULE]
+ * `lt`|`lte`|`gt`|`gte`:
+ * + rval must be a number. And lval will be converted to number (`numericToNumber`) to compare.
+ * `eq`:
+ * + If same type, compare with `===`.
+ * + If there is one number, convert to number (`numericToNumber`) to compare.
+ * + Else return `false`.
+ * `ne`:
+ * + Not `eq`.
+ *
+ *
+ * [SORT_COMPARISON_RULE]
+ * All the values are grouped into three categories:
+ * + "numeric" (number and numeric string)
+ * + "non-numeric-string" (string that excluding numeric string)
+ * + "others"
+ * "numeric" vs "numeric": values are ordered by number order.
+ * "non-numeric-string" vs "non-numeric-string": values are ordered by ES spec (#sec-abstract-relational-comparison).
+ * "others" vs "others": do not change order (always return 0).
+ * "numeric" vs "non-numeric-string": "non-numeric-string" is treated as "incomparable".
+ * "number" vs "others": "others" is treated as "incomparable".
+ * "non-numeric-string" vs "others": "others" is treated as "incomparable".
+ * "incomparable" will be seen as -Infinity or Infinity (depends on the settings).
+ * MEMO:
+ *   Non-numeric string sort makes sense when we need to put the items with the same tag together.
+ *   But if we support string sort, we still need to avoid the misleading like `'2' > '12'`,
+ *   So we treat "numeric-string" sorted by number order rather than string comparison.
+ *
+ *
+ * [CHECK_LIST_OF_THE_RULE_DESIGN]
+ * + Do not support string comparison until required. And also need to
+ *   avoid the misleading of "2" > "12".
+ * + Should avoid the misleading case:
+ *   `" 22 " gte "22"` is `true` but `" 22 " eq "22"` is `false`.
+ * + JS bad case should be avoided: null <= 0, [] <= 0, ' ' <= 0, ...
+ * + Only "numeric" can be converted to comparable number, otherwise converted to NaN.
+ *   See `util/number.ts#numericToNumber`.
+ *
+ * @return If `op` is not `RelationalOperator`, return null;
+ */
+function createFilterComparator(op, rval) {
+  return op === 'eq' || op === 'ne' ? new FilterEqualityComparator(op === 'eq', rval) : util.hasOwn(ORDER_COMPARISON_OP_MAP, op) ? new FilterOrderComparator(op, rval) : null;
+}
+
+exports.SortOrderComparator = SortOrderComparator;
+exports.createFilterComparator = createFilterComparator;
+exports.getRawValueParser = getRawValueParser;
+exports.parseDataValue = parseDataValue;