@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/helper/dataProvider.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const model = require("../../util/model.js");
+const Source = require("../Source.js");
+const types = require("../../util/types.js");
+var _a, _b, _c;
+var providerMethods;
+var mountMethods;
+var DefaultDataProvider = (
+  /** @class */
+  function() {
+    function DefaultDataProvider2(sourceParam, dimSize) {
+      var source = !Source.isSourceInstance(sourceParam) ? Source.createSourceFromSeriesDataOption(sourceParam) : sourceParam;
+      this._source = source;
+      var data = this._data = source.data;
+      if (source.sourceFormat === types.SOURCE_FORMAT_TYPED_ARRAY) {
+        this._offset = 0;
+        this._dimSize = dimSize;
+        this._data = data;
+      }
+      mountMethods(this, data, source);
+    }
+    DefaultDataProvider2.prototype.getSource = function() {
+      return this._source;
+    };
+    DefaultDataProvider2.prototype.count = function() {
+      return 0;
+    };
+    DefaultDataProvider2.prototype.getItem = function(idx, out) {
+      return;
+    };
+    DefaultDataProvider2.prototype.appendData = function(newData) {
+    };
+    DefaultDataProvider2.prototype.clean = function() {
+    };
+    DefaultDataProvider2.protoInitialize = function() {
+      var proto = DefaultDataProvider2.prototype;
+      proto.pure = false;
+      proto.persistent = true;
+    }();
+    DefaultDataProvider2.internalField = function() {
+      var _a2;
+      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)];
+        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++) {
+            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 = (_a2 = {}, _a2[types.SOURCE_FORMAT_ARRAY_ROWS + "_" + types.SERIES_LAYOUT_BY_COLUMN] = {
+        pure: true,
+        appendData: appendDataSimply
+      }, _a2[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".');
+        }
+      }, _a2[types.SOURCE_FORMAT_OBJECT_ROWS] = {
+        pure: true,
+        appendData: appendDataSimply
+      }, _a2[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]);
+            }
+          });
+        }
+      }, _a2[types.SOURCE_FORMAT_ORIGINAL] = {
+        appendData: appendDataSimply
+      }, _a2[types.SOURCE_FORMAT_TYPED_ARRAY] = {
+        persistent: false,
+        pure: true,
+        appendData: function(newData) {
+          this._data = newData;
+        },
+        // Clean self if data is already used.
+        clean: function() {
+          this._offset += this.count();
+          this._data = null;
+        }
+      }, _a2);
+      function appendDataSimply(newData) {
+        for (var i = 0; i < newData.length; i++) {
+          this._data.push(newData[i]);
+        }
+      }
+    }();
+    return DefaultDataProvider2;
+  }()
+);
+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;
+    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)];
+  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;
+  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)];
+  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) {
+  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];
+  return method;
+}
+function getMethodMapKey(sourceFormat, seriesLayoutBy) {
+  return sourceFormat === types.SOURCE_FORMAT_ARRAY_ROWS ? sourceFormat + "_" + seriesLayoutBy : sourceFormat;
+}
+function retrieveRawValue(data, dataIndex, dim) {
+  if (!data) {
+    return;
+  }
+  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/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/helper/dataStackHelper.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const SeriesDataSchema = require("./SeriesDataSchema.js");
+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;
+  }
+  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) {
+      if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) {
+        stackedByDimInfo = dimensionInfo;
+      }
+      if (!stackedDimInfo && dimensionInfo.type !== "ordinal" && dimensionInfo.type !== "time" && (!stackedCoordDimension || stackedCoordDimension === dimensionInfo.coordDim)) {
+        stackedDimInfo = dimensionInfo;
+      }
+    }
+  });
+  if (stackedDimInfo && !byIndex && !stackedByDimInfo) {
+    byIndex = true;
+  }
+  if (stackedDimInfo) {
+    stackResultDimension = "__\0ecstackresult_" + seriesModel.id;
+    stackedOverDimension = "__\0ecstackedover_" + seriesModel.id;
+    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,
+    stackResultDimension
+  };
+}
+function isLegacyDimensionsInput(dimensionsInput) {
+  return !SeriesDataSchema.isSeriesDataSchema(dimensionsInput.schema);
+}
+function isDimensionStacked(data, stackedDim) {
+  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/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/helper/dataValueHelper.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const number = require("../../util/number.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const log = require("../../util/log.js");
+function parseDataValue(value, opt) {
+  var dimType = opt && opt.type;
+  if (dimType === "ordinal") {
+    return value;
+  }
+  if (dimType === "time" && !util.isNumber(value) && value != null && value !== "-") {
+    value = +number.parseDate(value);
+  }
+  return value == null || value === "" ? NaN : Number(value);
+}
+var valueParserMap = util.createHashMap({
+  "number": function(val) {
+    return parseFloat(val);
+  },
+  "time": function(val) {
+    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 FilterOrderComparator2(op, rval) {
+      if (!util.isNumber(rval)) {
+        var errMsg = "";
+        log.throwError(errMsg);
+      }
+      this._opFn = ORDER_COMPARISON_OP_MAP[op];
+      this._rvalFloat = number.numericToNumber(rval);
+    }
+    FilterOrderComparator2.prototype.evaluate = function(lval) {
+      return util.isNumber(lval) ? this._opFn(lval, this._rvalFloat) : this._opFn(number.numericToNumber(lval), this._rvalFloat);
+    };
+    return FilterOrderComparator2;
+  }()
+);
+var SortOrderComparator = (
+  /** @class */
+  function() {
+    function SortOrderComparator2(order, incomparable) {
+      var isDesc = order === "desc";
+      this._resultLT = isDesc ? 1 : -1;
+      if (incomparable == null) {
+        incomparable = isDesc ? "min" : "max";
+      }
+      this._incomparable = incomparable === "min" ? -Infinity : Infinity;
+    }
+    SortOrderComparator2.prototype.evaluate = function(lval, rval) {
+      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 SortOrderComparator2;
+  }()
+);
+var FilterEqualityComparator = (
+  /** @class */
+  function() {
+    function FilterEqualityComparator2(isEq, rval) {
+      this._rval = rval;
+      this._isEQ = isEq;
+      this._rvalTypeof = typeof rval;
+      this._rvalFloat = number.numericToNumber(rval);
+    }
+    FilterEqualityComparator2.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 FilterEqualityComparator2;
+  }()
+);
+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;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/data/helper/dimensionHelper.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const types = require("../../util/types.js");
+var DimensionUserOuput = (
+  /** @class */
+  function() {
+    function DimensionUserOuput2(encode, dimRequest) {
+      this._encode = encode;
+      this._schema = dimRequest;
+    }
+    DimensionUserOuput2.prototype.get = function() {
+      return {
+        // Do not generate full dimension name until fist used.
+        fullDimensions: this._getFullDimensionNames(),
+        encode: this._encode
+      };
+    };
+    DimensionUserOuput2.prototype._getFullDimensionNames = function() {
+      if (!this._cachedDimNames) {
+        this._cachedDimNames = this._schema ? this._schema.makeOutputDimensionNames() : [];
+      }
+      return this._cachedDimNames;
+    };
+    return DimensionUserOuput2;
+  }()
+);
+function summarizeDimensions(data, schema) {
+  var summary = {};
+  var encode = summary.encode = {};
+  var notExtraCoordDimMap = util.createHashMap();
+  var defaultedLabel = [];
+  var defaultedTooltip = [];
+  var userOutputEncode = {};
+  util.each(data.dimensions, function(dimName) {
+    var dimItem = data.getDimensionInfo(dimName);
+    var coordDim = dimItem.coordDim;
+    if (coordDim) {
+      var coordDimIndex = dimItem.coordDimIndex;
+      getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName;
+      if (!dimItem.isExtraCoord) {
+        notExtraCoordDimMap.set(coordDim, 1);
+        if (mayLabelDimType(dimItem.type)) {
+          defaultedLabel[0] = dimName;
+        }
+        getOrCreateEncodeArr(userOutputEncode, coordDim)[coordDimIndex] = data.getDimensionIndex(dimItem.name);
+      }
+      if (dimItem.defaultTooltip) {
+        defaultedTooltip.push(dimName);
+      }
+    }
+    types.VISUAL_DIMENSIONS.each(function(v, otherDim) {
+      var encodeArr = getOrCreateEncodeArr(encode, otherDim);
+      var dimIndex = dimItem.otherDims[otherDim];
+      if (dimIndex != null && dimIndex !== false) {
+        encodeArr[dimIndex] = dimItem.name;
+      }
+    });
+  });
+  var dataDimsOnCoord = [];
+  var encodeFirstDimNotExtra = {};
+  notExtraCoordDimMap.each(function(v, coordDim) {
+    var dimArr = encode[coordDim];
+    encodeFirstDimNotExtra[coordDim] = dimArr[0];
+    dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);
+  });
+  summary.dataDimsOnCoord = dataDimsOnCoord;
+  summary.dataDimIndicesOnCoord = util.map(dataDimsOnCoord, function(dimName) {
+    return data.getDimensionInfo(dimName).storeDimIndex;
+  });
+  summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;
+  var encodeLabel = encode.label;
+  if (encodeLabel && encodeLabel.length) {
+    defaultedLabel = encodeLabel.slice();
+  }
+  var encodeTooltip = encode.tooltip;
+  if (encodeTooltip && encodeTooltip.length) {
+    defaultedTooltip = encodeTooltip.slice();
+  } else if (!defaultedTooltip.length) {
+    defaultedTooltip = defaultedLabel.slice();
+  }
+  encode.defaultedLabel = defaultedLabel;
+  encode.defaultedTooltip = defaultedTooltip;
+  summary.userOutput = new DimensionUserOuput(userOutputEncode, schema);
+  return summary;
+}
+function getOrCreateEncodeArr(encode, dim) {
+  if (!encode.hasOwnProperty(dim)) {
+    encode[dim] = [];
+  }
+  return encode[dim];
+}
+function getDimensionTypeByAxis(axisType) {
+  return axisType === "category" ? "ordinal" : axisType === "time" ? "time" : "float";
+}
+function mayLabelDimType(dimType) {
+  return !(dimType === "ordinal" || dimType === "time");
+}
+exports.getDimensionTypeByAxis = getDimensionTypeByAxis;
+exports.summarizeDimensions = summarizeDimensions;