@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/conditionalExpression.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const log = require("./log.js");
+const dataValueHelper = require("../data/helper/dataValueHelper.js");
+var RELATIONAL_EXPRESSION_OP_ALIAS_MAP = {
+  value: "eq",
+  // PENDING: not good for literal semantic?
+  "<": "lt",
+  "<=": "lte",
+  ">": "gt",
+  ">=": "gte",
+  "=": "eq",
+  "!=": "ne",
+  "<>": "ne"
+  // Might be misleading for sake of the difference between '==' and '===',
+  // so don't support them.
+  // '==': 'eq',
+  // '===': 'seq',
+  // '!==': 'sne'
+  // PENDING: Whether support some common alias "ge", "le", "neq"?
+  // ge: 'gte',
+  // le: 'lte',
+  // neq: 'ne',
+};
+var RegExpEvaluator = (
+  /** @class */
+  function() {
+    function RegExpEvaluator2(rVal) {
+      var condValue = this._condVal = util.isString(rVal) ? new RegExp(rVal) : util.isRegExp(rVal) ? rVal : null;
+      if (condValue == null) {
+        var errMsg = "";
+        log.throwError(errMsg);
+      }
+    }
+    RegExpEvaluator2.prototype.evaluate = function(lVal) {
+      var type = typeof lVal;
+      return util.isString(type) ? this._condVal.test(lVal) : util.isNumber(type) ? this._condVal.test(lVal + "") : false;
+    };
+    return RegExpEvaluator2;
+  }()
+);
+var ConstConditionInternal = (
+  /** @class */
+  function() {
+    function ConstConditionInternal2() {
+    }
+    ConstConditionInternal2.prototype.evaluate = function() {
+      return this.value;
+    };
+    return ConstConditionInternal2;
+  }()
+);
+var AndConditionInternal = (
+  /** @class */
+  function() {
+    function AndConditionInternal2() {
+    }
+    AndConditionInternal2.prototype.evaluate = function() {
+      var children = this.children;
+      for (var i = 0; i < children.length; i++) {
+        if (!children[i].evaluate()) {
+          return false;
+        }
+      }
+      return true;
+    };
+    return AndConditionInternal2;
+  }()
+);
+var OrConditionInternal = (
+  /** @class */
+  function() {
+    function OrConditionInternal2() {
+    }
+    OrConditionInternal2.prototype.evaluate = function() {
+      var children = this.children;
+      for (var i = 0; i < children.length; i++) {
+        if (children[i].evaluate()) {
+          return true;
+        }
+      }
+      return false;
+    };
+    return OrConditionInternal2;
+  }()
+);
+var NotConditionInternal = (
+  /** @class */
+  function() {
+    function NotConditionInternal2() {
+    }
+    NotConditionInternal2.prototype.evaluate = function() {
+      return !this.child.evaluate();
+    };
+    return NotConditionInternal2;
+  }()
+);
+var RelationalConditionInternal = (
+  /** @class */
+  function() {
+    function RelationalConditionInternal2() {
+    }
+    RelationalConditionInternal2.prototype.evaluate = function() {
+      var needParse = !!this.valueParser;
+      var getValue = this.getValue;
+      var tarValRaw = getValue(this.valueGetterParam);
+      var tarValParsed = needParse ? this.valueParser(tarValRaw) : null;
+      for (var i = 0; i < this.subCondList.length; i++) {
+        if (!this.subCondList[i].evaluate(needParse ? tarValParsed : tarValRaw)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    return RelationalConditionInternal2;
+  }()
+);
+function parseOption(exprOption, getters) {
+  if (exprOption === true || exprOption === false) {
+    var cond = new ConstConditionInternal();
+    cond.value = exprOption;
+    return cond;
+  }
+  var errMsg = "";
+  if (!isObjectNotArray(exprOption)) {
+    log.throwError(errMsg);
+  }
+  if (exprOption.and) {
+    return parseAndOrOption("and", exprOption, getters);
+  } else if (exprOption.or) {
+    return parseAndOrOption("or", exprOption, getters);
+  } else if (exprOption.not) {
+    return parseNotOption(exprOption, getters);
+  }
+  return parseRelationalOption(exprOption, getters);
+}
+function parseAndOrOption(op, exprOption, getters) {
+  var subOptionArr = exprOption[op];
+  var errMsg = "";
+  if (!util.isArray(subOptionArr)) {
+    log.throwError(errMsg);
+  }
+  if (!subOptionArr.length) {
+    log.throwError(errMsg);
+  }
+  var cond = op === "and" ? new AndConditionInternal() : new OrConditionInternal();
+  cond.children = util.map(subOptionArr, function(subOption) {
+    return parseOption(subOption, getters);
+  });
+  if (!cond.children.length) {
+    log.throwError(errMsg);
+  }
+  return cond;
+}
+function parseNotOption(exprOption, getters) {
+  var subOption = exprOption.not;
+  var errMsg = "";
+  if (!isObjectNotArray(subOption)) {
+    log.throwError(errMsg);
+  }
+  var cond = new NotConditionInternal();
+  cond.child = parseOption(subOption, getters);
+  if (!cond.child) {
+    log.throwError(errMsg);
+  }
+  return cond;
+}
+function parseRelationalOption(exprOption, getters) {
+  var errMsg = "";
+  var valueGetterParam = getters.prepareGetValue(exprOption);
+  var subCondList = [];
+  var exprKeys = util.keys(exprOption);
+  var parserName = exprOption.parser;
+  var valueParser = parserName ? dataValueHelper.getRawValueParser(parserName) : null;
+  for (var i = 0; i < exprKeys.length; i++) {
+    var keyRaw = exprKeys[i];
+    if (keyRaw === "parser" || getters.valueGetterAttrMap.get(keyRaw)) {
+      continue;
+    }
+    var op = util.hasOwn(RELATIONAL_EXPRESSION_OP_ALIAS_MAP, keyRaw) ? RELATIONAL_EXPRESSION_OP_ALIAS_MAP[keyRaw] : keyRaw;
+    var condValueRaw = exprOption[keyRaw];
+    var condValueParsed = valueParser ? valueParser(condValueRaw) : condValueRaw;
+    var evaluator = dataValueHelper.createFilterComparator(op, condValueParsed) || op === "reg" && new RegExpEvaluator(condValueParsed);
+    if (!evaluator) {
+      log.throwError(errMsg);
+    }
+    subCondList.push(evaluator);
+  }
+  if (!subCondList.length) {
+    log.throwError(errMsg);
+  }
+  var cond = new RelationalConditionInternal();
+  cond.valueGetterParam = valueGetterParam;
+  cond.valueParser = valueParser;
+  cond.getValue = getters.getValue;
+  cond.subCondList = subCondList;
+  return cond;
+}
+function isObjectNotArray(val) {
+  return util.isObject(val) && !util.isArrayLike(val);
+}
+var ConditionalExpressionParsed = (
+  /** @class */
+  function() {
+    function ConditionalExpressionParsed2(exprOption, getters) {
+      this._cond = parseOption(exprOption, getters);
+    }
+    ConditionalExpressionParsed2.prototype.evaluate = function() {
+      return this._cond.evaluate();
+    };
+    return ConditionalExpressionParsed2;
+  }()
+);
+function parseConditionalExpression(exprOption, getters) {
+  return new ConditionalExpressionParsed(exprOption, getters);
+}
+exports.parseConditionalExpression = parseConditionalExpression;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/decal.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const WeakMap = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/WeakMap.js");
+const LRU = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/LRU.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const number = require("./number.js");
+const symbol = require("./symbol.js");
+const graphic = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/canvas/graphic.js");
+const platform = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/platform.js");
+var decalMap = new WeakMap.default();
+var decalCache = new LRU.default(100);
+var decalKeys = ["symbol", "symbolSize", "symbolKeepAspect", "color", "backgroundColor", "dashArrayX", "dashArrayY", "maxTileWidth", "maxTileHeight"];
+function createOrUpdatePatternFromDecal(decalObject, api) {
+  if (decalObject === "none") {
+    return null;
+  }
+  var dpr = api.getDevicePixelRatio();
+  var zr = api.getZr();
+  var isSVG = zr.painter.type === "svg";
+  if (decalObject.dirty) {
+    decalMap["delete"](decalObject);
+  }
+  var oldPattern = decalMap.get(decalObject);
+  if (oldPattern) {
+    return oldPattern;
+  }
+  var decalOpt = util.defaults(decalObject, {
+    symbol: "rect",
+    symbolSize: 1,
+    symbolKeepAspect: true,
+    color: "rgba(0, 0, 0, 0.2)",
+    backgroundColor: null,
+    dashArrayX: 5,
+    dashArrayY: 5,
+    rotation: 0,
+    maxTileWidth: 512,
+    maxTileHeight: 512
+  });
+  if (decalOpt.backgroundColor === "none") {
+    decalOpt.backgroundColor = null;
+  }
+  var pattern = {
+    repeat: "repeat"
+  };
+  setPatternnSource(pattern);
+  pattern.rotation = decalOpt.rotation;
+  pattern.scaleX = pattern.scaleY = isSVG ? 1 : 1 / dpr;
+  decalMap.set(decalObject, pattern);
+  decalObject.dirty = false;
+  return pattern;
+  function setPatternnSource(pattern2) {
+    var keys = [dpr];
+    var isValidKey = true;
+    for (var i = 0; i < decalKeys.length; ++i) {
+      var value = decalOpt[decalKeys[i]];
+      if (value != null && !util.isArray(value) && !util.isString(value) && !util.isNumber(value) && typeof value !== "boolean") {
+        isValidKey = false;
+        break;
+      }
+      keys.push(value);
+    }
+    var cacheKey;
+    if (isValidKey) {
+      cacheKey = keys.join(",") + (isSVG ? "-svg" : "");
+      var cache = decalCache.get(cacheKey);
+      if (cache) {
+        isSVG ? pattern2.svgElement = cache : pattern2.image = cache;
+      }
+    }
+    var dashArrayX = normalizeDashArrayX(decalOpt.dashArrayX);
+    var dashArrayY = normalizeDashArrayY(decalOpt.dashArrayY);
+    var symbolArray = normalizeSymbolArray(decalOpt.symbol);
+    var lineBlockLengthsX = getLineBlockLengthX(dashArrayX);
+    var lineBlockLengthY = getLineBlockLengthY(dashArrayY);
+    var canvas = !isSVG && platform.platformApi.createCanvas();
+    var svgRoot = isSVG && {
+      tag: "g",
+      attrs: {},
+      key: "dcl",
+      children: []
+    };
+    var pSize = getPatternSize();
+    var ctx;
+    if (canvas) {
+      canvas.width = pSize.width * dpr;
+      canvas.height = pSize.height * dpr;
+      ctx = canvas.getContext("2d");
+    }
+    brushDecal();
+    if (isValidKey) {
+      decalCache.put(cacheKey, canvas || svgRoot);
+    }
+    pattern2.image = canvas;
+    pattern2.svgElement = svgRoot;
+    pattern2.svgWidth = pSize.width;
+    pattern2.svgHeight = pSize.height;
+    function getPatternSize() {
+      var width = 1;
+      for (var i2 = 0, xlen = lineBlockLengthsX.length; i2 < xlen; ++i2) {
+        width = number.getLeastCommonMultiple(width, lineBlockLengthsX[i2]);
+      }
+      var symbolRepeats = 1;
+      for (var i2 = 0, xlen = symbolArray.length; i2 < xlen; ++i2) {
+        symbolRepeats = number.getLeastCommonMultiple(symbolRepeats, symbolArray[i2].length);
+      }
+      width *= symbolRepeats;
+      var height = lineBlockLengthY * lineBlockLengthsX.length * symbolArray.length;
+      return {
+        width: Math.max(1, Math.min(width, decalOpt.maxTileWidth)),
+        height: Math.max(1, Math.min(height, decalOpt.maxTileHeight))
+      };
+    }
+    function brushDecal() {
+      if (ctx) {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        if (decalOpt.backgroundColor) {
+          ctx.fillStyle = decalOpt.backgroundColor;
+          ctx.fillRect(0, 0, canvas.width, canvas.height);
+        }
+      }
+      var ySum = 0;
+      for (var i2 = 0; i2 < dashArrayY.length; ++i2) {
+        ySum += dashArrayY[i2];
+      }
+      if (ySum <= 0) {
+        return;
+      }
+      var y = -lineBlockLengthY;
+      var yId = 0;
+      var yIdTotal = 0;
+      var xId0 = 0;
+      while (y < pSize.height) {
+        if (yId % 2 === 0) {
+          var symbolYId = yIdTotal / 2 % symbolArray.length;
+          var x = 0;
+          var xId1 = 0;
+          var xId1Total = 0;
+          while (x < pSize.width * 2) {
+            var xSum = 0;
+            for (var i2 = 0; i2 < dashArrayX[xId0].length; ++i2) {
+              xSum += dashArrayX[xId0][i2];
+            }
+            if (xSum <= 0) {
+              break;
+            }
+            if (xId1 % 2 === 0) {
+              var size = (1 - decalOpt.symbolSize) * 0.5;
+              var left = x + dashArrayX[xId0][xId1] * size;
+              var top_1 = y + dashArrayY[yId] * size;
+              var width = dashArrayX[xId0][xId1] * decalOpt.symbolSize;
+              var height = dashArrayY[yId] * decalOpt.symbolSize;
+              var symbolXId = xId1Total / 2 % symbolArray[symbolYId].length;
+              brushSymbol(left, top_1, width, height, symbolArray[symbolYId][symbolXId]);
+            }
+            x += dashArrayX[xId0][xId1];
+            ++xId1Total;
+            ++xId1;
+            if (xId1 === dashArrayX[xId0].length) {
+              xId1 = 0;
+            }
+          }
+          ++xId0;
+          if (xId0 === dashArrayX.length) {
+            xId0 = 0;
+          }
+        }
+        y += dashArrayY[yId];
+        ++yIdTotal;
+        ++yId;
+        if (yId === dashArrayY.length) {
+          yId = 0;
+        }
+      }
+      function brushSymbol(x2, y2, width2, height2, symbolType) {
+        var scale = isSVG ? 1 : dpr;
+        var symbol$1 = symbol.createSymbol(symbolType, x2 * scale, y2 * scale, width2 * scale, height2 * scale, decalOpt.color, decalOpt.symbolKeepAspect);
+        if (isSVG) {
+          var symbolVNode = zr.painter.renderOneToVNode(symbol$1);
+          if (symbolVNode) {
+            svgRoot.children.push(symbolVNode);
+          }
+        } else {
+          graphic.brushSingle(ctx, symbol$1);
+        }
+      }
+    }
+  }
+}
+function normalizeSymbolArray(symbol2) {
+  if (!symbol2 || symbol2.length === 0) {
+    return [["rect"]];
+  }
+  if (util.isString(symbol2)) {
+    return [[symbol2]];
+  }
+  var isAllString = true;
+  for (var i = 0; i < symbol2.length; ++i) {
+    if (!util.isString(symbol2[i])) {
+      isAllString = false;
+      break;
+    }
+  }
+  if (isAllString) {
+    return normalizeSymbolArray([symbol2]);
+  }
+  var result = [];
+  for (var i = 0; i < symbol2.length; ++i) {
+    if (util.isString(symbol2[i])) {
+      result.push([symbol2[i]]);
+    } else {
+      result.push(symbol2[i]);
+    }
+  }
+  return result;
+}
+function normalizeDashArrayX(dash) {
+  if (!dash || dash.length === 0) {
+    return [[0, 0]];
+  }
+  if (util.isNumber(dash)) {
+    var dashValue = Math.ceil(dash);
+    return [[dashValue, dashValue]];
+  }
+  var isAllNumber = true;
+  for (var i = 0; i < dash.length; ++i) {
+    if (!util.isNumber(dash[i])) {
+      isAllNumber = false;
+      break;
+    }
+  }
+  if (isAllNumber) {
+    return normalizeDashArrayX([dash]);
+  }
+  var result = [];
+  for (var i = 0; i < dash.length; ++i) {
+    if (util.isNumber(dash[i])) {
+      var dashValue = Math.ceil(dash[i]);
+      result.push([dashValue, dashValue]);
+    } else {
+      var dashValue = util.map(dash[i], function(n) {
+        return Math.ceil(n);
+      });
+      if (dashValue.length % 2 === 1) {
+        result.push(dashValue.concat(dashValue));
+      } else {
+        result.push(dashValue);
+      }
+    }
+  }
+  return result;
+}
+function normalizeDashArrayY(dash) {
+  if (!dash || typeof dash === "object" && dash.length === 0) {
+    return [0, 0];
+  }
+  if (util.isNumber(dash)) {
+    var dashValue_1 = Math.ceil(dash);
+    return [dashValue_1, dashValue_1];
+  }
+  var dashValue = util.map(dash, function(n) {
+    return Math.ceil(n);
+  });
+  return dash.length % 2 ? dashValue.concat(dashValue) : dashValue;
+}
+function getLineBlockLengthX(dash) {
+  return util.map(dash, function(line) {
+    return getLineBlockLengthY(line);
+  });
+}
+function getLineBlockLengthY(dash) {
+  var blockLength = 0;
+  for (var i = 0; i < dash.length; ++i) {
+    blockLength += dash[i];
+  }
+  if (dash.length % 2 === 1) {
+    return blockLength * 2;
+  }
+  return blockLength;
+}
+exports.createOrUpdatePatternFromDecal = createOrUpdatePatternFromDecal;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/event.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function findEventDispatcher(target, det, returnFirstMatch) {
+  var found;
+  while (target) {
+    if (det(target)) {
+      found = target;
+      if (returnFirstMatch) {
+        break;
+      }
+    }
+    target = target.__hostTarget || target.parent;
+  }
+  return found;
+}
+exports.findEventDispatcher = findEventDispatcher;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/format.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const dom = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/dom.js");
+const number = require("./number.js");
+const time = require("./time.js");
+function addCommas(x) {
+  if (!number.isNumeric(x)) {
+    return util.isString(x) ? x : "-";
+  }
+  var parts = (x + "").split(".");
+  return parts[0].replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, "$1,") + (parts.length > 1 ? "." + parts[1] : "");
+}
+function toCamelCase(str, upperCaseFirst) {
+  str = (str || "").toLowerCase().replace(/-(.)/g, function(match, group1) {
+    return group1.toUpperCase();
+  });
+  if (upperCaseFirst && str) {
+    str = str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return str;
+}
+var normalizeCssArray = util.normalizeCssArray;
+function makeValueReadable(value, valueType, useUTC) {
+  var USER_READABLE_DEFUALT_TIME_PATTERN = "{yyyy}-{MM}-{dd} {HH}:{mm}:{ss}";
+  function stringToUserReadable(str) {
+    return str && util.trim(str) ? str : "-";
+  }
+  function isNumberUserReadable(num) {
+    return !!(num != null && !isNaN(num) && isFinite(num));
+  }
+  var isTypeTime = valueType === "time";
+  var isValueDate = value instanceof Date;
+  if (isTypeTime || isValueDate) {
+    var date = isTypeTime ? number.parseDate(value) : value;
+    if (!isNaN(+date)) {
+      return time.format(date, USER_READABLE_DEFUALT_TIME_PATTERN, useUTC);
+    } else if (isValueDate) {
+      return "-";
+    }
+  }
+  if (valueType === "ordinal") {
+    return util.isStringSafe(value) ? stringToUserReadable(value) : util.isNumber(value) ? isNumberUserReadable(value) ? value + "" : "-" : "-";
+  }
+  var numericResult = number.numericToNumber(value);
+  return isNumberUserReadable(numericResult) ? addCommas(numericResult) : util.isStringSafe(value) ? stringToUserReadable(value) : typeof value === "boolean" ? value + "" : "-";
+}
+var TPL_VAR_ALIAS = ["a", "b", "c", "d", "e", "f", "g"];
+var wrapVar = function(varName, seriesIdx) {
+  return "{" + varName + (seriesIdx == null ? "" : seriesIdx) + "}";
+};
+function formatTpl(tpl, paramsList, encode) {
+  if (!util.isArray(paramsList)) {
+    paramsList = [paramsList];
+  }
+  var seriesLen = paramsList.length;
+  if (!seriesLen) {
+    return "";
+  }
+  var $vars = paramsList[0].$vars || [];
+  for (var i = 0; i < $vars.length; i++) {
+    var alias = TPL_VAR_ALIAS[i];
+    tpl = tpl.replace(wrapVar(alias), wrapVar(alias, 0));
+  }
+  for (var seriesIdx = 0; seriesIdx < seriesLen; seriesIdx++) {
+    for (var k = 0; k < $vars.length; k++) {
+      var val = paramsList[seriesIdx][$vars[k]];
+      tpl = tpl.replace(wrapVar(TPL_VAR_ALIAS[k], seriesIdx), encode ? dom.encodeHTML(val) : val);
+    }
+  }
+  return tpl;
+}
+function getTooltipMarker(inOpt, extraCssText) {
+  var opt = util.isString(inOpt) ? {
+    color: inOpt,
+    extraCssText
+  } : inOpt || {};
+  var color = opt.color;
+  var type = opt.type;
+  extraCssText = opt.extraCssText;
+  var renderMode = opt.renderMode || "html";
+  if (!color) {
+    return "";
+  }
+  if (renderMode === "html") {
+    return type === "subItem" ? '<span style="display:inline-block;vertical-align:middle;margin-right:8px;margin-left:3px;border-radius:4px;width:4px;height:4px;background-color:' + dom.encodeHTML(color) + ";" + (extraCssText || "") + '"></span>' : '<span style="display:inline-block;margin-right:4px;border-radius:10px;width:10px;height:10px;background-color:' + dom.encodeHTML(color) + ";" + (extraCssText || "") + '"></span>';
+  } else {
+    var markerId = opt.markerId || "markerX";
+    return {
+      renderMode,
+      content: "{" + markerId + "|}  ",
+      style: type === "subItem" ? {
+        width: 4,
+        height: 4,
+        borderRadius: 2,
+        backgroundColor: color
+      } : {
+        width: 10,
+        height: 10,
+        borderRadius: 5,
+        backgroundColor: color
+      }
+    };
+  }
+}
+function formatTime(tpl, value, isUTC) {
+  if (tpl === "week" || tpl === "month" || tpl === "quarter" || tpl === "half-year" || tpl === "year") {
+    tpl = "MM-dd\nyyyy";
+  }
+  var date = number.parseDate(value);
+  var getUTC = isUTC ? "getUTC" : "get";
+  var y = date[getUTC + "FullYear"]();
+  var M = date[getUTC + "Month"]() + 1;
+  var d = date[getUTC + "Date"]();
+  var h = date[getUTC + "Hours"]();
+  var m = date[getUTC + "Minutes"]();
+  var s = date[getUTC + "Seconds"]();
+  var S = date[getUTC + "Milliseconds"]();
+  tpl = tpl.replace("MM", time.pad(M, 2)).replace("M", M).replace("yyyy", y).replace("yy", time.pad(y % 100 + "", 2)).replace("dd", time.pad(d, 2)).replace("d", d).replace("hh", time.pad(h, 2)).replace("h", h).replace("mm", time.pad(m, 2)).replace("m", m).replace("ss", time.pad(s, 2)).replace("s", s).replace("SSS", time.pad(S, 3));
+  return tpl;
+}
+function capitalFirst(str) {
+  return str ? str.charAt(0).toUpperCase() + str.substr(1) : str;
+}
+function convertToColorString(color, defaultColor) {
+  defaultColor = defaultColor || "transparent";
+  return util.isString(color) ? color : util.isObject(color) ? color.colorStops && (color.colorStops[0] || {}).color || defaultColor : defaultColor;
+}
+function windowOpen(link, target) {
+  if (target === "_blank" || target === "blank") {
+    var blank = window.open();
+    blank.opener = null;
+    blank.location.href = link;
+  } else {
+    window.open(link, target);
+  }
+}
+exports.encodeHTML = dom.encodeHTML;
+exports.addCommas = addCommas;
+exports.capitalFirst = capitalFirst;
+exports.convertToColorString = convertToColorString;
+exports.formatTime = formatTime;
+exports.formatTpl = formatTpl;
+exports.getTooltipMarker = getTooltipMarker;
+exports.makeValueReadable = makeValueReadable;
+exports.normalizeCssArray = normalizeCssArray;
+exports.toCamelCase = toCamelCase;
+exports.windowOpen = windowOpen;