{"version":3,"sources":["webpack:///./node_modules/echarts/src/config.js","webpack:///./src/models/notifyModel.js","webpack:///./src/models/vanBanDenModel.js","webpack:///./node_modules/zrender/src/core/util.js","webpack:///./node_modules/echarts/src/util/clazz.js","webpack:///./node_modules/echarts/src/scale/Scale.js","webpack:///./node_modules/echarts/src/util/number.js","webpack:///./node_modules/zrender/src/core/vector.js","webpack:///./node_modules/zrender/src/core/matrix.js","webpack:///./node_modules/zrender/src/core/BoundingRect.js","webpack:///./node_modules/zrender/src/core/LRU.js","webpack:///./node_modules/zrender/src/graphic/helper/image.js","webpack:///./node_modules/zrender/src/contain/text.js","webpack:///./node_modules/echarts/src/util/format.js","webpack:///./node_modules/echarts/src/scale/helper.js","webpack:///./node_modules/echarts/src/scale/Interval.js","webpack:///./node_modules/echarts/src/scale/Log.js"],"names":["dev","window","__DEV__","global","addMessage","item","resultString","resultCode","fromJson","id","title","content","read","recipientId","recipient","senderId","url","baseJson","toListModel","items","lenght","data","map","value","index","push","notifyModel","toJson","version","number","loaiVanBan","loaiVanBanTen","trangThai","trangThaiTen","soLuuCV","soVBDen","ngayNhap","ngayBanHanh","ngayTraLoi","traLoiCVSo","soBan","trichYeu","donViSoan","donViSoanTen","canBoSoan","canBoSoanTen","hinhThucGui","hinhThucGuiTen","hanXuLy","linhVuc","linhVucTen","mucDoBaoMat","mucDoBaoMatTen","mucDoTinhChat","mucDoTinhChatTen","hoSoDonVi","hoSoDonViTen","noiLuuTru","coQuanNhan","coQuanNhanTen","congVanChiDoc","banChinh","hienThiThongBao","ngayNhan","coQuanGui","khoiCoQuanGui","hinhThucNhan","nguoiKy","capVanBan","butphe","donViNhanXuLy","phanCong","identity","nhomNguoiTiepNhanVBTrinhLD","noiDungXuLy","bgColor","code","color","ten","ngayKy","file","uploadFiles","nguoiPhanCong","butPhe","donViXuLy","filePDF","trinhLanhDaoTruong","ower","daXuLy","noiDung","ngayXuLy","sysNgayXuLy","files","length","vanBanDenModel","objToString","Object","prototype","toString","arrayProto","Array","nativeForEach","forEach","nativeSlice","filter","slice","nativeMap","methods","reduce","extend","target","source","key","hasOwnProperty","_ctx","createCanvas","getContext","inherits","clazz","baseClazz","clazzPrototype","F","prop","constructor","superClass","each","obj","cb","context","i","len","call","result","bind","func","args","arguments","apply","concat","isArray","Function","assert","condition","message","Error","document","createElement","HashMap","isArr","this","thisMap","visit","set","get","removeKey","TYPE_DELIMITER","IS_CONTAINER","parseClassType","componentType","ret","main","sub","split","checkClassType","test","enableClassExtend","RootClass","mandatoryMethods","$constructor","proto","method","console","warn","type","ExtendedClass","superCall","superApply","methodName","enableClassManagement","entity","options","storage","makeContainer","container","registerClass","Clazz","getClass","componentMainType","subType","throwWhenNotFound","getClassesByMainType","o","hasClass","getAllClassMainTypes","types","hasSubTypes","registerWhenExtend","originalExtend","Scale","setting","_setting","_extent","Infinity","_interval","init","parse","val","getSetting","name","contain","extent","normalize","scale","unionExtent","other","unionExtentFromData","dim","getApproximateExtent","getExtent","setExtent","start","end","thisExtent","isNaN","isBlank","_isBlank","setBlank","getLabel","round","x","precision","returnStr","Math","min","max","toFixed","getPrecisionSafe","str","eIndex","indexOf","dotIndex","quantity","pow","quantityExponent","exp","floor","log","LN10","nice","nf","exponent","exp10","f","Float32Array","applyTransform","out","v","m","y","translate","a","vx","vy","v2ApplyTransform","mathMin","mathMax","BoundingRect","width","height","union","lt","rb","lb","rt","maxX","maxY","calculateTransform","b","sx","sy","intersect","create","ax0","ax1","ay0","ay1","bx0","bx1","by0","by1","rect","clone","copy","plain","LinkedList","head","tail","_len","linkedListProto","insert","entry","Entry","insertEntry","next","prev","remove","clear","LRU","maxSize","_list","_map","_maxSize","_lastRemovedEntry","LRUProto","put","list","removed","leastUsedEntry","DEFAULT_FONT","addCommas","replace","measureText","text","font","ctx","roundNumber","intervalScaleNiceTicks","splitNumber","minInterval","maxInterval","span","interval","intervalPrecision","getIntervalPrecision","niceTickExtent","ceil","fixExtent","clamp","idx","isFinite","IntervalScale","_intervalPrecision","parseFloat","getInterval","setInterval","_niceExtent","getTicks","expandToNicedExtent","ticks","safeLimit","tick","lastNiceTick","getMinorTicks","minorTicks","nextTick","prevTick","count","minorTicksGroup","minorInterval","minorTick","opt","niceTicks","reverse","niceExtent","expandSize","fixMax","fixMin","Interval","scaleProto","intervalScaleProto","roundingErrorFix","mathFloor","mathCeil","mathPow","mathLog","LogScale","base","_originalScale","originalScale","originalExtent","powVal","__fixMin","fixRoundingError","__fixMax","approxTickNum","err","abs","originalVal"],"mappings":"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","file":"js/chunk-63748f90.29d2d8b5.js","sourcesContent":["/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n// (1) The code `if (__DEV__) ...` can be removed by build tool.\n// (2) If intend to use `__DEV__`, this module should be imported. Use a global\n// variable `__DEV__` may cause that miss the declaration (see #6535), or the\n// declaration is behind of the using position (for example in `Model.extent`,\n// And tools like rollup can not analysis the dependency if not import).\n\nvar dev;\n\n// In browser\nif (typeof window !== 'undefined') {\n    dev = window.__DEV__;\n}\n// In node\nelse if (typeof global !== 'undefined') {\n    dev = global.__DEV__;\n}\n\nif (typeof dev === 'undefined') {\n    dev = true;\n}\n\nexport var __DEV__ = dev;\n","const addMessage = (item) => {\n  return {\n    resultString: item.resultString,\n    resultCode: item.resultCode,\n  };\n};\n\nconst fromJson = (item) => {\n  return {\n    id: item.id,\n    title: item.title,\n    content: item.content,\n    read: item.read,\n    recipientId: item.recipientId,\n    recipient: item.recipient,\n    senderId: item.senderId,\n    url: item.url,\n  };\n};\n\nconst baseJson = () => {\n  return {\n    id: null,\n    title: null,\n    content: null,\n    read: null,\n    recipientId: null,\n    recipient: null,\n    senderId: null,\n    url: null,\n  };\n};\n\nconst toListModel = (items) => {\n  if (items.lenght > 0) {\n    let data = [];\n    items.map((value, index) => {\n      data.push(fromJson(value));\n    });\n    return data ?? [];\n  }\n  return [];\n};\n\nexport const notifyModel = { addMessage, fromJson, toListModel, baseJson };\n","import moment from \"moment\";\nconst toJson = (item) => {\n    return {\n        id: item.id,\n        version: item.version,\n        number: item.number,\n        loaiVanBan: item.loaiVanBan,\n        loaiVanBanTen: item.loaiVanBanTen,\n        trangThai: item.trangThai,\n        trangThaiTen: item.trangThaiTen,\n        soLuuCV: item.soLuuCV,\n        soVBDen: item.soVBDen,\n        ngayNhap: item.ngayNhap,\n        ngayBanHanh: item.ngayBanHanh,\n        ngayTraLoi: item.ngayTraLoi,\n        traLoiCVSo: item.traLoiCVSo,\n        soBan: item.soBan,\n        trichYeu: item.trichYeu,\n        donViSoan: item.donViSoan,\n        donViSoanTen: item.donViSoanTen,\n        canBoSoan: item.canBoSoan,\n        canBoSoanTen: item.canBoSoanTen,\n        hinhThucGui: item.hinhThucGui,\n        hinhThucGuiTen: item.hinhThucGuiTen,\n        hanXuLy: item.hanXuLy,\n        linhVuc: item.linhVuc,\n        linhVucTen: item.linhVucTen,\n        mucDoBaoMat: item.mucDoBaoMat,\n        mucDoBaoMatTen: item.mucDoBaoMatTen,\n        mucDoTinhChat: item.mucDoTinhChat,\n        mucDoTinhChatTen: item.mucDoTinhChatTen,\n        hoSoDonVi: item.hoSoDonVi,\n        hoSoDonViTen: item.hoSoDonViTen,\n        noiLuuTru: item.noiLuuTru,\n        coQuanNhan: item.coQuanNhan,\n        coQuanNhanTen: item.coQuanNhanTen,\n        congVanChiDoc: item.congVanChiDoc,\n        banChinh: item.banChinh,\n        hienThiThongBao: item.hienThiThongBao,\n        ngayNhan: item.ngayNhan,\n        coQuanGui: item.coQuanGui,\n        khoiCoQuanGui: item.khoiCoQuanGui,\n        hinhThucNhan: item.hinhThucNhan,\n        nguoiKy: item.nguoiKy,\n        capVanBan: item.capVanBan,\n        butphe: item.butphe,\n        donViNhanXuLy: item.donViNhanXuLy,\n        phanCong: item.phanCong,\n        identity: item.identity,\n        nhomNguoiTiepNhanVBTrinhLD: item.nhomNguoiTiepNhanVBTrinhLD,\n        noiDungXuLy: item.noiDungXuLy\n    }\n}\nconst fromJson = (item) => {\n    return {\n        id: item.id,\n        version: item.version,\n        number: item.number,\n        loaiVanBan: item.loaiVanBan,\n        loaiVanBanTen: item.loaiVanBanTen,\n        trangThai: item.trangThai,\n        trangThaiTen: item.trangThaiTen,\n        soLuuCV: item.soLuuCV,\n        soVBDen: item.soVBDen,\n        ngayNhap: item.ngayNhap,\n        ngayTraLoi: item.ngayTraLoi,\n        ngayBanHanh: item.ngayBanHanh,\n        traLoiCVSo: item.traLoiCVSo,\n        soBan: item.soBan,\n        trichYeu: item.trichYeu,\n        donViSoan: item.donViSoan,\n        donViSoanTen: item.donViSoanTen,\n        canBoSoan: item.canBoSoan,\n        canBoSoanTen: item.canBoSoanTen,\n        hinhThucGui: item.hinhThucGui,\n        hinhThucGuiTen: item.hinhThucGuiTen,\n        hanXuLy: item.hanXuLy,\n        linhVuc: item.linhVuc,\n        linhVucTen: item.linhVucTen,\n        mucDoBaoMat: item.mucDoBaoMat,\n        mucDoBaoMatTen: item.mucDoBaoMatTen,\n        mucDoTinhChat: item.mucDoTinhChat,\n        mucDoTinhChatTen: item.mucDoTinhChatTen,\n        hoSoDonVi: item.hoSoDonVi,\n        hoSoDonViTen: item.hoSoDonViTen,\n        noiLuuTru: item.noiLuuTru,\n        coQuanNhan: item.coQuanNhan,\n        coQuanNhanTen: item.coQuanNhanTen,\n        congVanChiDoc: item.congVanChiDoc,\n        banChinh: item.banChinh,\n        hienThiThongBao: item.hienThiThongBao,\n        ngayNhan: item.ngayNhan,\n        coQuanGui: item.coQuanGui,\n        khoiCoQuanGui: item.khoiCoQuanGui,\n        hinhThucNhan: item.hinhThucNhan,\n        nguoiKy: item.nguoiKy,\n        capVanBan: item.capVanBan,\n        butphe: item.butphe,\n        donViNhanXuLy: item.donViNhanXuLy,\n        phanCong: item.phanCong,\n        identity: item.identity,\n        nhomNguoiTiepNhanVBTrinhLD: item.nhomNguoiTiepNhanVBTrinhLD,\n        noiDungXuLy: item.noiDungXuLy\n    }\n}\n\nconst baseJson = (items) => {\n    return {\n        version: 1,\n        id: null,\n        number: 0,\n        loaiVanBan: null,\n        trangThai:{\n            bgColor: \"success\",\n            code: \"KTVBD\",\n            color: \"#ad0000\",\n            id: \"62ee8cff7174613162d17884\",\n            ten: \"Khởi tạo VBD\"\n        },\n        soLuuCV: null,\n        soVBDen: null,\n        ngayBanHanh: null,\n        trichYeu: null,\n        hinhThucNhan: null,\n        hanXuLy: null,\n        linhVuc: null,\n        mucDoBaoMat: null,\n        capVanBan: {\n            code: \"TRUONG\",\n            id: \"63b4cdcea067d30d1157e202\",\n            ten: \"Cấp trường\"\n        },\n        mucDoTinhChat: null,\n        hoSoDonVi: null,\n        noiLuuTru: null,\n        congVanChiDoc: false,\n        banChinh: false,\n        hienThiThongBao: false,\n        ngayNhan: null,\n        coQuanGui: null,\n        khoiCoQuanGui: null,\n        nguoiKy: null,\n        ngayKy: null,\n        file: null,\n        uploadFiles: null,\n\n        nguoiPhanCong: null,\n        butPhe: null,\n        phanCong: null,\n        donViXuLy: null,\n        identity: 0,\n        filePDF: null,\n        trinhLanhDaoTruong: false,\n        ower: null,\n        nhomNguoiTiepNhanVBTrinhLD: null,\n        noiDungXuLy: {\n            daXuLy: false,\n            noiDung: null,\n            ngayXuLy: null,\n            sysNgayXuLy: null,\n            files: null\n        }\n    }\n}\n\nconst toListModel = (items) =>{\n    if(items.length > 0){\n        let data = [];\n        items.map((value, index) =>{\n            data.push(fromJson(value));\n        })\n        return data??[];\n    }\n    return [];\n}\n\nexport const vanBanDenModel = {\n    toJson, fromJson, baseJson, toListModel\n}\n","/**\n * @module zrender/core/util\n */\n\n// 用于处理merge时无法遍历Date等对象的问题\nvar BUILTIN_OBJECT = {\n    '[object Function]': 1,\n    '[object RegExp]': 1,\n    '[object Date]': 1,\n    '[object Error]': 1,\n    '[object CanvasGradient]': 1,\n    '[object CanvasPattern]': 1,\n    // For node-canvas\n    '[object Image]': 1,\n    '[object Canvas]': 1\n};\n\nvar TYPED_ARRAY = {\n    '[object Int8Array]': 1,\n    '[object Uint8Array]': 1,\n    '[object Uint8ClampedArray]': 1,\n    '[object Int16Array]': 1,\n    '[object Uint16Array]': 1,\n    '[object Int32Array]': 1,\n    '[object Uint32Array]': 1,\n    '[object Float32Array]': 1,\n    '[object Float64Array]': 1\n};\n\nvar objToString = Object.prototype.toString;\n\nvar arrayProto = Array.prototype;\nvar nativeForEach = arrayProto.forEach;\nvar nativeFilter = arrayProto.filter;\nvar nativeSlice = arrayProto.slice;\nvar nativeMap = arrayProto.map;\nvar nativeReduce = arrayProto.reduce;\n\n// Avoid assign to an exported variable, for transforming to cjs.\nvar methods = {};\n\nexport function $override(name, fn) {\n    // Clear ctx instance for different environment\n    if (name === 'createCanvas') {\n        _ctx = null;\n    }\n\n    methods[name] = fn;\n}\n\n/**\n * Those data types can be cloned:\n *     Plain object, Array, TypedArray, number, string, null, undefined.\n * Those data types will be assgined using the orginal data:\n *     BUILTIN_OBJECT\n * Instance of user defined class will be cloned to a plain object, without\n * properties in prototype.\n * Other data types is not supported (not sure what will happen).\n *\n * Caution: do not support clone Date, for performance consideration.\n * (There might be a large number of date in `series.data`).\n * So date should not be modified in and out of echarts.\n *\n * @param {*} source\n * @return {*} new\n */\nexport function clone(source) {\n    if (source == null || typeof source !== 'object') {\n        return source;\n    }\n\n    var result = source;\n    var typeStr = objToString.call(source);\n\n    if (typeStr === '[object Array]') {\n        if (!isPrimitive(source)) {\n            result = [];\n            for (var i = 0, len = source.length; i < len; i++) {\n                result[i] = clone(source[i]);\n            }\n        }\n    }\n    else if (TYPED_ARRAY[typeStr]) {\n        if (!isPrimitive(source)) {\n            var Ctor = source.constructor;\n            if (source.constructor.from) {\n                result = Ctor.from(source);\n            }\n            else {\n                result = new Ctor(source.length);\n                for (var i = 0, len = source.length; i < len; i++) {\n                    result[i] = clone(source[i]);\n                }\n            }\n        }\n    }\n    else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {\n        result = {};\n        for (var key in source) {\n            if (source.hasOwnProperty(key)) {\n                result[key] = clone(source[key]);\n            }\n        }\n    }\n\n    return result;\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} target\n * @param {*} source\n * @param {boolean} [overwrite=false]\n */\nexport function merge(target, source, overwrite) {\n    // We should escapse that source is string\n    // and enter for ... in ...\n    if (!isObject(source) || !isObject(target)) {\n        return overwrite ? clone(source) : target;\n    }\n\n    for (var key in source) {\n        if (source.hasOwnProperty(key)) {\n            var targetProp = target[key];\n            var sourceProp = source[key];\n\n            if (isObject(sourceProp)\n                && isObject(targetProp)\n                && !isArray(sourceProp)\n                && !isArray(targetProp)\n                && !isDom(sourceProp)\n                && !isDom(targetProp)\n                && !isBuiltInObject(sourceProp)\n                && !isBuiltInObject(targetProp)\n                && !isPrimitive(sourceProp)\n                && !isPrimitive(targetProp)\n            ) {\n                // 如果需要递归覆盖，就递归调用merge\n                merge(targetProp, sourceProp, overwrite);\n            }\n            else if (overwrite || !(key in target)) {\n                // 否则只处理overwrite为true，或者在目标对象中没有此属性的情况\n                // NOTE，在 target[key] 不存在的时候也是直接覆盖\n                target[key] = clone(source[key], true);\n            }\n        }\n    }\n\n    return target;\n}\n\n/**\n * @param {Array} targetAndSources The first item is target, and the rests are source.\n * @param {boolean} [overwrite=false]\n * @return {*} target\n */\nexport function mergeAll(targetAndSources, overwrite) {\n    var result = targetAndSources[0];\n    for (var i = 1, len = targetAndSources.length; i < len; i++) {\n        result = merge(result, targetAndSources[i], overwrite);\n    }\n    return result;\n}\n\n/**\n * @param {*} target\n * @param {*} source\n * @memberOf module:zrender/core/util\n */\nexport function extend(target, source) {\n    for (var key in source) {\n        if (source.hasOwnProperty(key)) {\n            target[key] = source[key];\n        }\n    }\n    return target;\n}\n\n/**\n * @param {*} target\n * @param {*} source\n * @param {boolean} [overlay=false]\n * @memberOf module:zrender/core/util\n */\nexport function defaults(target, source, overlay) {\n    for (var key in source) {\n        if (source.hasOwnProperty(key)\n            && (overlay ? source[key] != null : target[key] == null)\n        ) {\n            target[key] = source[key];\n        }\n    }\n    return target;\n}\n\nexport var createCanvas = function () {\n    return methods.createCanvas();\n};\n\nmethods.createCanvas = function () {\n    return document.createElement('canvas');\n};\n\n// FIXME\nvar _ctx;\n\nexport function getContext() {\n    if (!_ctx) {\n        // Use util.createCanvas instead of createCanvas\n        // because createCanvas may be overwritten in different environment\n        _ctx = createCanvas().getContext('2d');\n    }\n    return _ctx;\n}\n\n/**\n * 查询数组中元素的index\n * @memberOf module:zrender/core/util\n */\nexport function indexOf(array, value) {\n    if (array) {\n        if (array.indexOf) {\n            return array.indexOf(value);\n        }\n        for (var i = 0, len = array.length; i < len; i++) {\n            if (array[i] === value) {\n                return i;\n            }\n        }\n    }\n    return -1;\n}\n\n/**\n * 构造类继承关系\n *\n * @memberOf module:zrender/core/util\n * @param {Function} clazz 源类\n * @param {Function} baseClazz 基类\n */\nexport function inherits(clazz, baseClazz) {\n    var clazzPrototype = clazz.prototype;\n    function F() {}\n    F.prototype = baseClazz.prototype;\n    clazz.prototype = new F();\n\n    for (var prop in clazzPrototype) {\n        if (clazzPrototype.hasOwnProperty(prop)) {\n            clazz.prototype[prop] = clazzPrototype[prop];\n        }\n    }\n    clazz.prototype.constructor = clazz;\n    clazz.superClass = baseClazz;\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {Object|Function} target\n * @param {Object|Function} sorce\n * @param {boolean} overlay\n */\nexport function mixin(target, source, overlay) {\n    target = 'prototype' in target ? target.prototype : target;\n    source = 'prototype' in source ? source.prototype : source;\n\n    defaults(target, source, overlay);\n}\n\n/**\n * Consider typed array.\n * @param {Array|TypedArray} data\n */\nexport function isArrayLike(data) {\n    if (!data) {\n        return;\n    }\n    if (typeof data === 'string') {\n        return false;\n    }\n    return typeof data.length === 'number';\n}\n\n/**\n * 数组或对象遍历\n * @memberOf module:zrender/core/util\n * @param {Object|Array} obj\n * @param {Function} cb\n * @param {*} [context]\n */\nexport function each(obj, cb, context) {\n    if (!(obj && cb)) {\n        return;\n    }\n    if (obj.forEach && obj.forEach === nativeForEach) {\n        obj.forEach(cb, context);\n    }\n    else if (obj.length === +obj.length) {\n        for (var i = 0, len = obj.length; i < len; i++) {\n            cb.call(context, obj[i], i, obj);\n        }\n    }\n    else {\n        for (var key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                cb.call(context, obj[key], key, obj);\n            }\n        }\n    }\n}\n\n/**\n * 数组映射\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {Array}\n */\nexport function map(obj, cb, context) {\n    if (!(obj && cb)) {\n        return;\n    }\n    if (obj.map && obj.map === nativeMap) {\n        return obj.map(cb, context);\n    }\n    else {\n        var result = [];\n        for (var i = 0, len = obj.length; i < len; i++) {\n            result.push(cb.call(context, obj[i], i, obj));\n        }\n        return result;\n    }\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {Object} [memo]\n * @param {*} [context]\n * @return {Array}\n */\nexport function reduce(obj, cb, memo, context) {\n    if (!(obj && cb)) {\n        return;\n    }\n    if (obj.reduce && obj.reduce === nativeReduce) {\n        return obj.reduce(cb, memo, context);\n    }\n    else {\n        for (var i = 0, len = obj.length; i < len; i++) {\n            memo = cb.call(context, memo, obj[i], i, obj);\n        }\n        return memo;\n    }\n}\n\n/**\n * 数组过滤\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {Array}\n */\nexport function filter(obj, cb, context) {\n    if (!(obj && cb)) {\n        return;\n    }\n    if (obj.filter && obj.filter === nativeFilter) {\n        return obj.filter(cb, context);\n    }\n    else {\n        var result = [];\n        for (var i = 0, len = obj.length; i < len; i++) {\n            if (cb.call(context, obj[i], i, obj)) {\n                result.push(obj[i]);\n            }\n        }\n        return result;\n    }\n}\n\n/**\n * 数组项查找\n * @memberOf module:zrender/core/util\n * @param {Array} obj\n * @param {Function} cb\n * @param {*} [context]\n * @return {*}\n */\nexport function find(obj, cb, context) {\n    if (!(obj && cb)) {\n        return;\n    }\n    for (var i = 0, len = obj.length; i < len; i++) {\n        if (cb.call(context, obj[i], i, obj)) {\n            return obj[i];\n        }\n    }\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {Function} func\n * @param {*} context\n * @return {Function}\n */\nexport function bind(func, context) {\n    var args = nativeSlice.call(arguments, 2);\n    return function () {\n        return func.apply(context, args.concat(nativeSlice.call(arguments)));\n    };\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {Function} func\n * @return {Function}\n */\nexport function curry(func) {\n    var args = nativeSlice.call(arguments, 1);\n    return function () {\n        return func.apply(this, args.concat(nativeSlice.call(arguments)));\n    };\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isArray(value) {\n    return objToString.call(value) === '[object Array]';\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isFunction(value) {\n    return typeof value === 'function';\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isString(value) {\n    return objToString.call(value) === '[object String]';\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isObject(value) {\n    // Avoid a V8 JIT bug in Chrome 19-20.\n    // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n    var type = typeof value;\n    return type === 'function' || (!!value && type === 'object');\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isBuiltInObject(value) {\n    return !!BUILTIN_OBJECT[objToString.call(value)];\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isTypedArray(value) {\n    return !!TYPED_ARRAY[objToString.call(value)];\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {*} value\n * @return {boolean}\n */\nexport function isDom(value) {\n    return typeof value === 'object'\n        && typeof value.nodeType === 'number'\n        && typeof value.ownerDocument === 'object';\n}\n\n/**\n * Whether is exactly NaN. Notice isNaN('a') returns true.\n * @param {*} value\n * @return {boolean}\n */\nexport function eqNaN(value) {\n    /* eslint-disable-next-line no-self-compare */\n    return value !== value;\n}\n\n/**\n * If value1 is not null, then return value1, otherwise judget rest of values.\n * Low performance.\n * @memberOf module:zrender/core/util\n * @return {*} Final value\n */\nexport function retrieve(values) {\n    for (var i = 0, len = arguments.length; i < len; i++) {\n        if (arguments[i] != null) {\n            return arguments[i];\n        }\n    }\n}\n\nexport function retrieve2(value0, value1) {\n    return value0 != null\n        ? value0\n        : value1;\n}\n\nexport function retrieve3(value0, value1, value2) {\n    return value0 != null\n        ? value0\n        : value1 != null\n        ? value1\n        : value2;\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {Array} arr\n * @param {number} startIndex\n * @param {number} endIndex\n * @return {Array}\n */\nexport function slice() {\n    return Function.call.apply(nativeSlice, arguments);\n}\n\n/**\n * Normalize css liked array configuration\n * e.g.\n *  3 => [3, 3, 3, 3]\n *  [4, 2] => [4, 2, 4, 2]\n *  [4, 3, 2] => [4, 3, 2, 3]\n * @param {number|Array.<number>} val\n * @return {Array.<number>}\n */\nexport function normalizeCssArray(val) {\n    if (typeof (val) === 'number') {\n        return [val, val, val, val];\n    }\n    var len = val.length;\n    if (len === 2) {\n        // vertical | horizontal\n        return [val[0], val[1], val[0], val[1]];\n    }\n    else if (len === 3) {\n        // top | horizontal | bottom\n        return [val[0], val[1], val[2], val[1]];\n    }\n    return val;\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {boolean} condition\n * @param {string} message\n */\nexport function assert(condition, message) {\n    if (!condition) {\n        throw new Error(message);\n    }\n}\n\n/**\n * @memberOf module:zrender/core/util\n * @param {string} str string to be trimed\n * @return {string} trimed string\n */\nexport function trim(str) {\n    if (str == null) {\n        return null;\n    }\n    else if (typeof str.trim === 'function') {\n        return str.trim();\n    }\n    else {\n        return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n    }\n}\n\nvar primitiveKey = '__ec_primitive__';\n/**\n * Set an object as primitive to be ignored traversing children in clone or merge\n */\nexport function setAsPrimitive(obj) {\n    obj[primitiveKey] = true;\n}\n\nexport function isPrimitive(obj) {\n    return obj[primitiveKey];\n}\n\n/**\n * @constructor\n * @param {Object} obj Only apply `ownProperty`.\n */\nfunction HashMap(obj) {\n    var isArr = isArray(obj);\n    // Key should not be set on this, otherwise\n    // methods get/set/... may be overrided.\n    this.data = {};\n    var thisMap = this;\n\n    (obj instanceof HashMap)\n        ? obj.each(visit)\n        : (obj && each(obj, visit));\n\n    function visit(value, key) {\n        isArr ? thisMap.set(value, key) : thisMap.set(key, value);\n    }\n}\n\nHashMap.prototype = {\n    constructor: HashMap,\n    // Do not provide `has` method to avoid defining what is `has`.\n    // (We usually treat `null` and `undefined` as the same, different\n    // from ES6 Map).\n    get: function (key) {\n        return this.data.hasOwnProperty(key) ? this.data[key] : null;\n    },\n    set: function (key, value) {\n        // Comparing with invocation chaining, `return value` is more commonly\n        // used in this case: `var someVal = map.set('a', genVal());`\n        return (this.data[key] = value);\n    },\n    // Although util.each can be performed on this hashMap directly, user\n    // should not use the exposed keys, who are prefixed.\n    each: function (cb, context) {\n        context !== void 0 && (cb = bind(cb, context));\n        /* eslint-disable guard-for-in */\n        for (var key in this.data) {\n            this.data.hasOwnProperty(key) && cb(this.data[key], key);\n        }\n        /* eslint-enable guard-for-in */\n    },\n    // Do not use this method if performance sensitive.\n    removeKey: function (key) {\n        delete this.data[key];\n    }\n};\n\nexport function createHashMap(obj) {\n    return new HashMap(obj);\n}\n\nexport function concatArray(a, b) {\n    var newArray = new a.constructor(a.length + b.length);\n    for (var i = 0; i < a.length; i++) {\n        newArray[i] = a[i];\n    }\n    var offset = a.length;\n    for (i = 0; i < b.length; i++) {\n        newArray[i + offset] = b[i];\n    }\n    return newArray;\n}\n\n\nexport function noop() {}\n","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nimport {__DEV__} from '../config';\nimport * as zrUtil from 'zrender/src/core/util';\n\nvar TYPE_DELIMITER = '.';\nvar IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';\n\n/**\n * Notice, parseClassType('') should returns {main: '', sub: ''}\n * @public\n */\nexport function parseClassType(componentType) {\n    var ret = {main: '', sub: ''};\n    if (componentType) {\n        componentType = componentType.split(TYPE_DELIMITER);\n        ret.main = componentType[0] || '';\n        ret.sub = componentType[1] || '';\n    }\n    return ret;\n}\n\n/**\n * @public\n */\nfunction checkClassType(componentType) {\n    zrUtil.assert(\n        /^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType),\n        'componentType \"' + componentType + '\" illegal'\n    );\n}\n\n/**\n * @public\n */\nexport function enableClassExtend(RootClass, mandatoryMethods) {\n\n    RootClass.$constructor = RootClass;\n    RootClass.extend = function (proto) {\n\n        if (__DEV__) {\n            zrUtil.each(mandatoryMethods, function (method) {\n                if (!proto[method]) {\n                    console.warn(\n                        'Method `' + method + '` should be implemented'\n                        + (proto.type ? ' in ' + proto.type : '') + '.'\n                    );\n                }\n            });\n        }\n\n        var superClass = this;\n        var ExtendedClass = function () {\n            if (!proto.$constructor) {\n                superClass.apply(this, arguments);\n            }\n            else {\n                proto.$constructor.apply(this, arguments);\n            }\n        };\n\n        zrUtil.extend(ExtendedClass.prototype, proto);\n\n        ExtendedClass.extend = this.extend;\n        ExtendedClass.superCall = superCall;\n        ExtendedClass.superApply = superApply;\n        zrUtil.inherits(ExtendedClass, this);\n        ExtendedClass.superClass = superClass;\n\n        return ExtendedClass;\n    };\n}\n\nvar classBase = 0;\n\n/**\n * Can not use instanceof, consider different scope by\n * cross domain or es module import in ec extensions.\n * Mount a method \"isInstance()\" to Clz.\n */\nexport function enableClassCheck(Clz) {\n    var classAttr = ['__\\0is_clz', classBase++, Math.random().toFixed(3)].join('_');\n    Clz.prototype[classAttr] = true;\n\n    if (__DEV__) {\n        zrUtil.assert(!Clz.isInstance, 'The method \"is\" can not be defined.');\n    }\n\n    Clz.isInstance = function (obj) {\n        return !!(obj && obj[classAttr]);\n    };\n}\n\n// superCall should have class info, which can not be fetch from 'this'.\n// Consider this case:\n// class A has method f,\n// class B inherits class A, overrides method f, f call superApply('f'),\n// class C inherits class B, do not overrides method f,\n// then when method of class C is called, dead loop occured.\nfunction superCall(context, methodName) {\n    var args = zrUtil.slice(arguments, 2);\n    return this.superClass.prototype[methodName].apply(context, args);\n}\n\nfunction superApply(context, methodName, args) {\n    return this.superClass.prototype[methodName].apply(context, args);\n}\n\n/**\n * @param {Object} entity\n * @param {Object} options\n * @param {boolean} [options.registerWhenExtend]\n * @public\n */\nexport function enableClassManagement(entity, options) {\n    options = options || {};\n\n    /**\n     * Component model classes\n     * key: componentType,\n     * value:\n     *     componentClass, when componentType is 'xxx'\n     *     or Object.<subKey, componentClass>, when componentType is 'xxx.yy'\n     * @type {Object}\n     */\n    var storage = {};\n\n    entity.registerClass = function (Clazz, componentType) {\n        if (componentType) {\n            checkClassType(componentType);\n            componentType = parseClassType(componentType);\n\n            if (!componentType.sub) {\n                if (__DEV__) {\n                    if (storage[componentType.main]) {\n                        console.warn(componentType.main + ' exists.');\n                    }\n                }\n                storage[componentType.main] = Clazz;\n            }\n            else if (componentType.sub !== IS_CONTAINER) {\n                var container = makeContainer(componentType);\n                container[componentType.sub] = Clazz;\n            }\n        }\n        return Clazz;\n    };\n\n    entity.getClass = function (componentMainType, subType, throwWhenNotFound) {\n        var Clazz = storage[componentMainType];\n\n        if (Clazz && Clazz[IS_CONTAINER]) {\n            Clazz = subType ? Clazz[subType] : null;\n        }\n\n        if (throwWhenNotFound && !Clazz) {\n            throw new Error(\n                !subType\n                    ? componentMainType + '.' + 'type should be specified.'\n                    : 'Component ' + componentMainType + '.' + (subType || '') + ' not exists. Load it first.'\n            );\n        }\n\n        return Clazz;\n    };\n\n    entity.getClassesByMainType = function (componentType) {\n        componentType = parseClassType(componentType);\n\n        var result = [];\n        var obj = storage[componentType.main];\n\n        if (obj && obj[IS_CONTAINER]) {\n            zrUtil.each(obj, function (o, type) {\n                type !== IS_CONTAINER && result.push(o);\n            });\n        }\n        else {\n            result.push(obj);\n        }\n\n        return result;\n    };\n\n    entity.hasClass = function (componentType) {\n        // Just consider componentType.main.\n        componentType = parseClassType(componentType);\n        return !!storage[componentType.main];\n    };\n\n    /**\n     * @return {Array.<string>} Like ['aa', 'bb'], but can not be ['aa.xx']\n     */\n    entity.getAllClassMainTypes = function () {\n        var types = [];\n        zrUtil.each(storage, function (obj, type) {\n            types.push(type);\n        });\n        return types;\n    };\n\n    /**\n     * If a main type is container and has sub types\n     * @param  {string}  mainType\n     * @return {boolean}\n     */\n    entity.hasSubTypes = function (componentType) {\n        componentType = parseClassType(componentType);\n        var obj = storage[componentType.main];\n        return obj && obj[IS_CONTAINER];\n    };\n\n    entity.parseClassType = parseClassType;\n\n    function makeContainer(componentType) {\n        var container = storage[componentType.main];\n        if (!container || !container[IS_CONTAINER]) {\n            container = storage[componentType.main] = {};\n            container[IS_CONTAINER] = true;\n        }\n        return container;\n    }\n\n    if (options.registerWhenExtend) {\n        var originalExtend = entity.extend;\n        if (originalExtend) {\n            entity.extend = function (proto) {\n                var ExtendedClass = originalExtend.call(this, proto);\n                return entity.registerClass(ExtendedClass, proto.type);\n            };\n        }\n    }\n\n    return entity;\n}\n\n/**\n * @param {string|Array.<string>} properties\n */\nexport function setReadOnly(obj, properties) {\n    // FIXME It seems broken in IE8 simulation of IE11\n    // if (!zrUtil.isArray(properties)) {\n    //     properties = properties != null ? [properties] : [];\n    // }\n    // zrUtil.each(properties, function (prop) {\n    //     var value = obj[prop];\n\n    //     Object.defineProperty\n    //         && Object.defineProperty(obj, prop, {\n    //             value: value, writable: false\n    //         });\n    //     zrUtil.isArray(obj[prop])\n    //         && Object.freeze\n    //         && Object.freeze(obj[prop]);\n    // });\n}\n","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * // Scale class management\n * @module echarts/scale/Scale\n */\n\nimport * as clazzUtil from '../util/clazz';\n\n/**\n * @param {Object} [setting]\n */\nfunction Scale(setting) {\n    this._setting = setting || {};\n\n    /**\n     * Extent\n     * @type {Array.<number>}\n     * @protected\n     */\n    this._extent = [Infinity, -Infinity];\n\n    /**\n     * Step is calculated in adjustExtent\n     * @type {Array.<number>}\n     * @protected\n     */\n    this._interval = 0;\n\n    this.init && this.init.apply(this, arguments);\n}\n\n/**\n * Parse input val to valid inner number.\n * @param {*} val\n * @return {number}\n */\nScale.prototype.parse = function (val) {\n    // Notice: This would be a trap here, If the implementation\n    // of this method depends on extent, and this method is used\n    // before extent set (like in dataZoom), it would be wrong.\n    // Nevertheless, parse does not depend on extent generally.\n    return val;\n};\n\nScale.prototype.getSetting = function (name) {\n    return this._setting[name];\n};\n\nScale.prototype.contain = function (val) {\n    var extent = this._extent;\n    return val >= extent[0] && val <= extent[1];\n};\n\n/**\n * Normalize value to linear [0, 1], return 0.5 if extent span is 0\n * @param {number} val\n * @return {number}\n */\nScale.prototype.normalize = function (val) {\n    var extent = this._extent;\n    if (extent[1] === extent[0]) {\n        return 0.5;\n    }\n    return (val - extent[0]) / (extent[1] - extent[0]);\n};\n\n/**\n * Scale normalized value\n * @param {number} val\n * @return {number}\n */\nScale.prototype.scale = function (val) {\n    var extent = this._extent;\n    return val * (extent[1] - extent[0]) + extent[0];\n};\n\n/**\n * Set extent from data\n * @param {Array.<number>} other\n */\nScale.prototype.unionExtent = function (other) {\n    var extent = this._extent;\n    other[0] < extent[0] && (extent[0] = other[0]);\n    other[1] > extent[1] && (extent[1] = other[1]);\n    // not setExtent because in log axis it may transformed to power\n    // this.setExtent(extent[0], extent[1]);\n};\n\n/**\n * Set extent from data\n * @param {module:echarts/data/List} data\n * @param {string} dim\n */\nScale.prototype.unionExtentFromData = function (data, dim) {\n    this.unionExtent(data.getApproximateExtent(dim));\n};\n\n/**\n * Get extent\n * @return {Array.<number>}\n */\nScale.prototype.getExtent = function () {\n    return this._extent.slice();\n};\n\n/**\n * Set extent\n * @param {number} start\n * @param {number} end\n */\nScale.prototype.setExtent = function (start, end) {\n    var thisExtent = this._extent;\n    if (!isNaN(start)) {\n        thisExtent[0] = start;\n    }\n    if (!isNaN(end)) {\n        thisExtent[1] = end;\n    }\n};\n\n/**\n * When axis extent depends on data and no data exists,\n * axis ticks should not be drawn, which is named 'blank'.\n */\nScale.prototype.isBlank = function () {\n    return this._isBlank;\n},\n\n/**\n * When axis extent depends on data and no data exists,\n * axis ticks should not be drawn, which is named 'blank'.\n */\nScale.prototype.setBlank = function (isBlank) {\n    this._isBlank = isBlank;\n};\n\n/**\n * @abstract\n * @param {*} tick\n * @return {string} label of the tick.\n */\nScale.prototype.getLabel = null;\n\n\nclazzUtil.enableClassExtend(Scale);\nclazzUtil.enableClassManagement(Scale, {\n    registerWhenExtend: true\n});\n\nexport default Scale;","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* A third-party license is embeded for some of the code in this file:\n* The method \"quantile\" was copied from \"d3.js\".\n* (See more details in the comment of the method below.)\n* The use of the source code of this file is also subject to the terms\n* and consitions of the license of \"d3.js\" (BSD-3Clause, see\n* </licenses/LICENSE-d3>).\n*/\n\nimport * as zrUtil from 'zrender/src/core/util';\n\nvar RADIAN_EPSILON = 1e-4;\n\nfunction _trim(str) {\n    return str.replace(/^\\s+|\\s+$/g, '');\n}\n\n/**\n * Linear mapping a value from domain to range\n * @memberOf module:echarts/util/number\n * @param  {(number|Array.<number>)} val\n * @param  {Array.<number>} domain Domain extent domain[0] can be bigger than domain[1]\n * @param  {Array.<number>} range  Range extent range[0] can be bigger than range[1]\n * @param  {boolean} clamp\n * @return {(number|Array.<number>}\n */\nexport function linearMap(val, domain, range, clamp) {\n    var subDomain = domain[1] - domain[0];\n    var subRange = range[1] - range[0];\n\n    if (subDomain === 0) {\n        return subRange === 0\n            ? range[0]\n            : (range[0] + range[1]) / 2;\n    }\n\n    // Avoid accuracy problem in edge, such as\n    // 146.39 - 62.83 === 83.55999999999999.\n    // See echarts/test/ut/spec/util/number.js#linearMap#accuracyError\n    // It is a little verbose for efficiency considering this method\n    // is a hotspot.\n    if (clamp) {\n        if (subDomain > 0) {\n            if (val <= domain[0]) {\n                return range[0];\n            }\n            else if (val >= domain[1]) {\n                return range[1];\n            }\n        }\n        else {\n            if (val >= domain[0]) {\n                return range[0];\n            }\n            else if (val <= domain[1]) {\n                return range[1];\n            }\n        }\n    }\n    else {\n        if (val === domain[0]) {\n            return range[0];\n        }\n        if (val === domain[1]) {\n            return range[1];\n        }\n    }\n\n    return (val - domain[0]) / subDomain * subRange + range[0];\n}\n\n/**\n * Convert a percent string to absolute number.\n * Returns NaN if percent is not a valid string or number\n * @memberOf module:echarts/util/number\n * @param {string|number} percent\n * @param {number} all\n * @return {number}\n */\nexport function parsePercent(percent, all) {\n    switch (percent) {\n        case 'center':\n        case 'middle':\n            percent = '50%';\n            break;\n        case 'left':\n        case 'top':\n            percent = '0%';\n            break;\n        case 'right':\n        case 'bottom':\n            percent = '100%';\n            break;\n    }\n    if (typeof percent === 'string') {\n        if (_trim(percent).match(/%$/)) {\n            return parseFloat(percent) / 100 * all;\n        }\n\n        return parseFloat(percent);\n    }\n\n    return percent == null ? NaN : +percent;\n}\n\n/**\n * (1) Fix rounding error of float numbers.\n * (2) Support return string to avoid scientific notation like '3.5e-7'.\n *\n * @param {number} x\n * @param {number} [precision]\n * @param {boolean} [returnStr]\n * @return {number|string}\n */\nexport function round(x, precision, returnStr) {\n    if (precision == null) {\n        precision = 10;\n    }\n    // Avoid range error\n    precision = Math.min(Math.max(0, precision), 20);\n    x = (+x).toFixed(precision);\n    return returnStr ? x : +x;\n}\n\n/**\n * asc sort arr.\n * The input arr will be modified.\n *\n * @param {Array} arr\n * @return {Array} The input arr.\n */\nexport function asc(arr) {\n    arr.sort(function (a, b) {\n        return a - b;\n    });\n    return arr;\n}\n\n/**\n * Get precision\n * @param {number} val\n */\nexport function getPrecision(val) {\n    val = +val;\n    if (isNaN(val)) {\n        return 0;\n    }\n    // It is much faster than methods converting number to string as follows\n    //      var tmp = val.toString();\n    //      return tmp.length - 1 - tmp.indexOf('.');\n    // especially when precision is low\n    var e = 1;\n    var count = 0;\n    while (Math.round(val * e) / e !== val) {\n        e *= 10;\n        count++;\n    }\n    return count;\n}\n\n/**\n * @param {string|number} val\n * @return {number}\n */\nexport function getPrecisionSafe(val) {\n    var str = val.toString();\n\n    // Consider scientific notation: '3.4e-12' '3.4e+12'\n    var eIndex = str.indexOf('e');\n    if (eIndex > 0) {\n        var precision = +str.slice(eIndex + 1);\n        return precision < 0 ? -precision : 0;\n    }\n    else {\n        var dotIndex = str.indexOf('.');\n        return dotIndex < 0 ? 0 : str.length - 1 - dotIndex;\n    }\n}\n\n/**\n * Minimal dicernible data precisioin according to a single pixel.\n *\n * @param {Array.<number>} dataExtent\n * @param {Array.<number>} pixelExtent\n * @return {number} precision\n */\nexport function getPixelPrecision(dataExtent, pixelExtent) {\n    var log = Math.log;\n    var LN10 = Math.LN10;\n    var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);\n    var sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10);\n    // toFixed() digits argument must be between 0 and 20.\n    var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);\n    return !isFinite(precision) ? 20 : precision;\n}\n\n/**\n * Get a data of given precision, assuring the sum of percentages\n * in valueList is 1.\n * The largest remainer method is used.\n * https://en.wikipedia.org/wiki/Largest_remainder_method\n *\n * @param {Array.<number>} valueList a list of all data\n * @param {number} idx index of the data to be processed in valueList\n * @param {number} precision integer number showing digits of precision\n * @return {number} percent ranging from 0 to 100\n */\nexport function getPercentWithPrecision(valueList, idx, precision) {\n    if (!valueList[idx]) {\n        return 0;\n    }\n\n    var sum = zrUtil.reduce(valueList, function (acc, val) {\n        return acc + (isNaN(val) ? 0 : val);\n    }, 0);\n    if (sum === 0) {\n        return 0;\n    }\n\n    var digits = Math.pow(10, precision);\n    var votesPerQuota = zrUtil.map(valueList, function (val) {\n        return (isNaN(val) ? 0 : val) / sum * digits * 100;\n    });\n    var targetSeats = digits * 100;\n\n    var seats = zrUtil.map(votesPerQuota, function (votes) {\n        // Assign automatic seats.\n        return Math.floor(votes);\n    });\n    var currentSum = zrUtil.reduce(seats, function (acc, val) {\n        return acc + val;\n    }, 0);\n\n    var remainder = zrUtil.map(votesPerQuota, function (votes, idx) {\n        return votes - seats[idx];\n    });\n\n    // Has remainding votes.\n    while (currentSum < targetSeats) {\n        // Find next largest remainder.\n        var max = Number.NEGATIVE_INFINITY;\n        var maxId = null;\n        for (var i = 0, len = remainder.length; i < len; ++i) {\n            if (remainder[i] > max) {\n                max = remainder[i];\n                maxId = i;\n            }\n        }\n\n        // Add a vote to max remainder.\n        ++seats[maxId];\n        remainder[maxId] = 0;\n        ++currentSum;\n    }\n\n    return seats[idx] / digits;\n}\n\n// Number.MAX_SAFE_INTEGER, ie do not support.\nexport var MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * To 0 - 2 * PI, considering negative radian.\n * @param {number} radian\n * @return {number}\n */\nexport function remRadian(radian) {\n    var pi2 = Math.PI * 2;\n    return (radian % pi2 + pi2) % pi2;\n}\n\n/**\n * @param {type} radian\n * @return {boolean}\n */\nexport function isRadianAroundZero(val) {\n    return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;\n}\n\n/* eslint-disable */\nvar TIME_REG = /^(?:(\\d{4})(?:[-\\/](\\d{1,2})(?:[-\\/](\\d{1,2})(?:[T ](\\d{1,2})(?::(\\d\\d)(?::(\\d\\d)(?:[.,](\\d+))?)?)?(Z|[\\+\\-]\\d\\d:?\\d\\d)?)?)?)?)?$/; // jshint ignore:line\n/* eslint-enable */\n\n/**\n * @param {string|Date|number} value These values can be accepted:\n *   + An instance of Date, represent a time in its own time zone.\n *   + Or string in a subset of ISO 8601, only including:\n *     + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',\n *     + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',\n *     + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',\n *     all of which will be treated as local time if time zone is not specified\n *     (see <https://momentjs.com/>).\n *   + Or other string format, including (all of which will be treated as loacal time):\n *     '2012', '2012-3-1', '2012/3/1', '2012/03/01',\n *     '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'\n *   + a timestamp, which represent a time in UTC.\n * @return {Date} date\n */\nexport function parseDate(value) {\n    if (value instanceof Date) {\n        return value;\n    }\n    else if (typeof value === 'string') {\n        // Different browsers parse date in different way, so we parse it manually.\n        // Some other issues:\n        // new Date('1970-01-01') is UTC,\n        // new Date('1970/01/01') and new Date('1970-1-01') is local.\n        // See issue #3623\n        var match = TIME_REG.exec(value);\n\n        if (!match) {\n            // return Invalid Date.\n            return new Date(NaN);\n        }\n\n        // Use local time when no timezone offset specifed.\n        if (!match[8]) {\n            // match[n] can only be string or undefined.\n            // But take care of '12' + 1 => '121'.\n            return new Date(\n                +match[1],\n                +(match[2] || 1) - 1,\n                +match[3] || 1,\n                +match[4] || 0,\n                +(match[5] || 0),\n                +match[6] || 0,\n                +match[7] || 0\n            );\n        }\n        // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,\n        // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).\n        // For example, system timezone is set as \"Time Zone: America/Toronto\",\n        // then these code will get different result:\n        // `new Date(1478411999999).getTimezoneOffset();  // get 240`\n        // `new Date(1478412000000).getTimezoneOffset();  // get 300`\n        // So we should not use `new Date`, but use `Date.UTC`.\n        else {\n            var hour = +match[4] || 0;\n            if (match[8].toUpperCase() !== 'Z') {\n                hour -= match[8].slice(0, 3);\n            }\n            return new Date(Date.UTC(\n                +match[1],\n                +(match[2] || 1) - 1,\n                +match[3] || 1,\n                hour,\n                +(match[5] || 0),\n                +match[6] || 0,\n                +match[7] || 0\n            ));\n        }\n    }\n    else if (value == null) {\n        return new Date(NaN);\n    }\n\n    return new Date(Math.round(value));\n}\n\n/**\n * Quantity of a number. e.g. 0.1, 1, 10, 100\n *\n * @param  {number} val\n * @return {number}\n */\nexport function quantity(val) {\n    return Math.pow(10, quantityExponent(val));\n}\n\n/**\n * Exponent of the quantity of a number\n * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3\n *\n * @param  {number} val non-negative value\n * @return {number}\n */\nexport function quantityExponent(val) {\n    if (val === 0) {\n        return 0;\n    }\n\n    var exp = Math.floor(Math.log(val) / Math.LN10);\n    /**\n     * exp is expected to be the rounded-down result of the base-10 log of val.\n     * But due to the precision loss with Math.log(val), we need to restore it\n     * using 10^exp to make sure we can get val back from exp. #11249\n     */\n    if (val / Math.pow(10, exp) >= 10) {\n        exp++;\n    }\n    return exp;\n}\n\n/**\n * find a “nice” number approximately equal to x. Round the number if round = true,\n * take ceiling if round = false. The primary observation is that the “nicest”\n * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.\n *\n * See \"Nice Numbers for Graph Labels\" of Graphic Gems.\n *\n * @param  {number} val Non-negative value.\n * @param  {boolean} round\n * @return {number}\n */\nexport function nice(val, round) {\n    var exponent = quantityExponent(val);\n    var exp10 = Math.pow(10, exponent);\n    var f = val / exp10; // 1 <= f < 10\n    var nf;\n    if (round) {\n        if (f < 1.5) {\n            nf = 1;\n        }\n        else if (f < 2.5) {\n            nf = 2;\n        }\n        else if (f < 4) {\n            nf = 3;\n        }\n        else if (f < 7) {\n            nf = 5;\n        }\n        else {\n            nf = 10;\n        }\n    }\n    else {\n        if (f < 1) {\n            nf = 1;\n        }\n        else if (f < 2) {\n            nf = 2;\n        }\n        else if (f < 3) {\n            nf = 3;\n        }\n        else if (f < 5) {\n            nf = 5;\n        }\n        else {\n            nf = 10;\n        }\n    }\n    val = nf * exp10;\n\n    // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).\n    // 20 is the uppper bound of toFixed.\n    return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;\n}\n\n/**\n * This code was copied from \"d3.js\"\n * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.\n * See the license statement at the head of this file.\n * @param {Array.<number>} ascArr\n */\nexport function quantile(ascArr, p) {\n    var H = (ascArr.length - 1) * p + 1;\n    var h = Math.floor(H);\n    var v = +ascArr[h - 1];\n    var e = H - h;\n    return e ? v + e * (ascArr[h] - v) : v;\n}\n\n/**\n * Order intervals asc, and split them when overlap.\n * expect(numberUtil.reformIntervals([\n *     {interval: [18, 62], close: [1, 1]},\n *     {interval: [-Infinity, -70], close: [0, 0]},\n *     {interval: [-70, -26], close: [1, 1]},\n *     {interval: [-26, 18], close: [1, 1]},\n *     {interval: [62, 150], close: [1, 1]},\n *     {interval: [106, 150], close: [1, 1]},\n *     {interval: [150, Infinity], close: [0, 0]}\n * ])).toEqual([\n *     {interval: [-Infinity, -70], close: [0, 0]},\n *     {interval: [-70, -26], close: [1, 1]},\n *     {interval: [-26, 18], close: [0, 1]},\n *     {interval: [18, 62], close: [0, 1]},\n *     {interval: [62, 150], close: [0, 1]},\n *     {interval: [150, Infinity], close: [0, 0]}\n * ]);\n * @param {Array.<Object>} list, where `close` mean open or close\n *        of the interval, and Infinity can be used.\n * @return {Array.<Object>} The origin list, which has been reformed.\n */\nexport function reformIntervals(list) {\n    list.sort(function (a, b) {\n        return littleThan(a, b, 0) ? -1 : 1;\n    });\n\n    var curr = -Infinity;\n    var currClose = 1;\n    for (var i = 0; i < list.length;) {\n        var interval = list[i].interval;\n        var close = list[i].close;\n\n        for (var lg = 0; lg < 2; lg++) {\n            if (interval[lg] <= curr) {\n                interval[lg] = curr;\n                close[lg] = !lg ? 1 - currClose : 1;\n            }\n            curr = interval[lg];\n            currClose = close[lg];\n        }\n\n        if (interval[0] === interval[1] && close[0] * close[1] !== 1) {\n            list.splice(i, 1);\n        }\n        else {\n            i++;\n        }\n    }\n\n    return list;\n\n    function littleThan(a, b, lg) {\n        return a.interval[lg] < b.interval[lg]\n            || (\n                a.interval[lg] === b.interval[lg]\n                && (\n                    (a.close[lg] - b.close[lg] === (!lg ? 1 : -1))\n                    || (!lg && littleThan(a, b, 1))\n                )\n            );\n    }\n}\n\n/**\n * parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n * ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n * subtraction forces infinities to NaN\n *\n * @param {*} v\n * @return {boolean}\n */\nexport function isNumeric(v) {\n    return v - parseFloat(v) >= 0;\n}\n","/* global Float32Array */\n\nvar ArrayCtor = typeof Float32Array === 'undefined'\n    ? Array\n    : Float32Array;\n\n/**\n * 创建一个向量\n * @param {number} [x=0]\n * @param {number} [y=0]\n * @return {Vector2}\n */\nexport function create(x, y) {\n    var out = new ArrayCtor(2);\n    if (x == null) {\n        x = 0;\n    }\n    if (y == null) {\n        y = 0;\n    }\n    out[0] = x;\n    out[1] = y;\n    return out;\n}\n\n/**\n * 复制向量数据\n * @param {Vector2} out\n * @param {Vector2} v\n * @return {Vector2}\n */\nexport function copy(out, v) {\n    out[0] = v[0];\n    out[1] = v[1];\n    return out;\n}\n\n/**\n * 克隆一个向量\n * @param {Vector2} v\n * @return {Vector2}\n */\nexport function clone(v) {\n    var out = new ArrayCtor(2);\n    out[0] = v[0];\n    out[1] = v[1];\n    return out;\n}\n\n/**\n * 设置向量的两个项\n * @param {Vector2} out\n * @param {number} a\n * @param {number} b\n * @return {Vector2} 结果\n */\nexport function set(out, a, b) {\n    out[0] = a;\n    out[1] = b;\n    return out;\n}\n\n/**\n * 向量相加\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\nexport function add(out, v1, v2) {\n    out[0] = v1[0] + v2[0];\n    out[1] = v1[1] + v2[1];\n    return out;\n}\n\n/**\n * 向量缩放后相加\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @param {number} a\n */\nexport function scaleAndAdd(out, v1, v2, a) {\n    out[0] = v1[0] + v2[0] * a;\n    out[1] = v1[1] + v2[1] * a;\n    return out;\n}\n\n/**\n * 向量相减\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\nexport function sub(out, v1, v2) {\n    out[0] = v1[0] - v2[0];\n    out[1] = v1[1] - v2[1];\n    return out;\n}\n\n/**\n * 向量长度\n * @param {Vector2} v\n * @return {number}\n */\nexport function len(v) {\n    return Math.sqrt(lenSquare(v));\n}\nexport var length = len; // jshint ignore:line\n\n/**\n * 向量长度平方\n * @param {Vector2} v\n * @return {number}\n */\nexport function lenSquare(v) {\n    return v[0] * v[0] + v[1] * v[1];\n}\nexport var lengthSquare = lenSquare;\n\n/**\n * 向量乘法\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\nexport function mul(out, v1, v2) {\n    out[0] = v1[0] * v2[0];\n    out[1] = v1[1] * v2[1];\n    return out;\n}\n\n/**\n * 向量除法\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n */\nexport function div(out, v1, v2) {\n    out[0] = v1[0] / v2[0];\n    out[1] = v1[1] / v2[1];\n    return out;\n}\n\n/**\n * 向量点乘\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\nexport function dot(v1, v2) {\n    return v1[0] * v2[0] + v1[1] * v2[1];\n}\n\n/**\n * 向量缩放\n * @param {Vector2} out\n * @param {Vector2} v\n * @param {number} s\n */\nexport function scale(out, v, s) {\n    out[0] = v[0] * s;\n    out[1] = v[1] * s;\n    return out;\n}\n\n/**\n * 向量归一化\n * @param {Vector2} out\n * @param {Vector2} v\n */\nexport function normalize(out, v) {\n    var d = len(v);\n    if (d === 0) {\n        out[0] = 0;\n        out[1] = 0;\n    }\n    else {\n        out[0] = v[0] / d;\n        out[1] = v[1] / d;\n    }\n    return out;\n}\n\n/**\n * 计算向量间距离\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\nexport function distance(v1, v2) {\n    return Math.sqrt(\n        (v1[0] - v2[0]) * (v1[0] - v2[0])\n        + (v1[1] - v2[1]) * (v1[1] - v2[1])\n    );\n}\nexport var dist = distance;\n\n/**\n * 向量距离平方\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @return {number}\n */\nexport function distanceSquare(v1, v2) {\n    return (v1[0] - v2[0]) * (v1[0] - v2[0])\n        + (v1[1] - v2[1]) * (v1[1] - v2[1]);\n}\nexport var distSquare = distanceSquare;\n\n/**\n * 求负向量\n * @param {Vector2} out\n * @param {Vector2} v\n */\nexport function negate(out, v) {\n    out[0] = -v[0];\n    out[1] = -v[1];\n    return out;\n}\n\n/**\n * 插值两个点\n * @param {Vector2} out\n * @param {Vector2} v1\n * @param {Vector2} v2\n * @param {number} t\n */\nexport function lerp(out, v1, v2, t) {\n    out[0] = v1[0] + t * (v2[0] - v1[0]);\n    out[1] = v1[1] + t * (v2[1] - v1[1]);\n    return out;\n}\n\n/**\n * 矩阵左乘向量\n * @param {Vector2} out\n * @param {Vector2} v\n * @param {Vector2} m\n */\nexport function applyTransform(out, v, m) {\n    var x = v[0];\n    var y = v[1];\n    out[0] = m[0] * x + m[2] * y + m[4];\n    out[1] = m[1] * x + m[3] * y + m[5];\n    return out;\n}\n\n/**\n * 求两个向量最小值\n * @param  {Vector2} out\n * @param  {Vector2} v1\n * @param  {Vector2} v2\n */\nexport function min(out, v1, v2) {\n    out[0] = Math.min(v1[0], v2[0]);\n    out[1] = Math.min(v1[1], v2[1]);\n    return out;\n}\n\n/**\n * 求两个向量最大值\n * @param  {Vector2} out\n * @param  {Vector2} v1\n * @param  {Vector2} v2\n */\nexport function max(out, v1, v2) {\n    out[0] = Math.max(v1[0], v2[0]);\n    out[1] = Math.max(v1[1], v2[1]);\n    return out;\n}\n","/**\n * 3x2矩阵操作类\n * @exports zrender/tool/matrix\n */\n\n/* global Float32Array */\n\nvar ArrayCtor = typeof Float32Array === 'undefined'\n    ? Array\n    : Float32Array;\n\n/**\n * Create a identity matrix.\n * @return {Float32Array|Array.<number>}\n */\nexport function create() {\n    var out = new ArrayCtor(6);\n    identity(out);\n\n    return out;\n}\n\n/**\n * 设置矩阵为单位矩阵\n * @param {Float32Array|Array.<number>} out\n */\nexport function identity(out) {\n    out[0] = 1;\n    out[1] = 0;\n    out[2] = 0;\n    out[3] = 1;\n    out[4] = 0;\n    out[5] = 0;\n    return out;\n}\n\n/**\n * 复制矩阵\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} m\n */\nexport function copy(out, m) {\n    out[0] = m[0];\n    out[1] = m[1];\n    out[2] = m[2];\n    out[3] = m[3];\n    out[4] = m[4];\n    out[5] = m[5];\n    return out;\n}\n\n/**\n * 矩阵相乘\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} m1\n * @param {Float32Array|Array.<number>} m2\n */\nexport function mul(out, m1, m2) {\n    // Consider matrix.mul(m, m2, m);\n    // where out is the same as m2.\n    // So use temp variable to escape error.\n    var out0 = m1[0] * m2[0] + m1[2] * m2[1];\n    var out1 = m1[1] * m2[0] + m1[3] * m2[1];\n    var out2 = m1[0] * m2[2] + m1[2] * m2[3];\n    var out3 = m1[1] * m2[2] + m1[3] * m2[3];\n    var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];\n    var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];\n    out[0] = out0;\n    out[1] = out1;\n    out[2] = out2;\n    out[3] = out3;\n    out[4] = out4;\n    out[5] = out5;\n    return out;\n}\n\n/**\n * 平移变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {Float32Array|Array.<number>} v\n */\nexport function translate(out, a, v) {\n    out[0] = a[0];\n    out[1] = a[1];\n    out[2] = a[2];\n    out[3] = a[3];\n    out[4] = a[4] + v[0];\n    out[5] = a[5] + v[1];\n    return out;\n}\n\n/**\n * 旋转变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {number} rad\n */\nexport function rotate(out, a, rad) {\n    var aa = a[0];\n    var ac = a[2];\n    var atx = a[4];\n    var ab = a[1];\n    var ad = a[3];\n    var aty = a[5];\n    var st = Math.sin(rad);\n    var ct = Math.cos(rad);\n\n    out[0] = aa * ct + ab * st;\n    out[1] = -aa * st + ab * ct;\n    out[2] = ac * ct + ad * st;\n    out[3] = -ac * st + ct * ad;\n    out[4] = ct * atx + st * aty;\n    out[5] = ct * aty - st * atx;\n    return out;\n}\n\n/**\n * 缩放变换\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n * @param {Float32Array|Array.<number>} v\n */\nexport function scale(out, a, v) {\n    var vx = v[0];\n    var vy = v[1];\n    out[0] = a[0] * vx;\n    out[1] = a[1] * vy;\n    out[2] = a[2] * vx;\n    out[3] = a[3] * vy;\n    out[4] = a[4] * vx;\n    out[5] = a[5] * vy;\n    return out;\n}\n\n/**\n * 求逆矩阵\n * @param {Float32Array|Array.<number>} out\n * @param {Float32Array|Array.<number>} a\n */\nexport function invert(out, a) {\n\n    var aa = a[0];\n    var ac = a[2];\n    var atx = a[4];\n    var ab = a[1];\n    var ad = a[3];\n    var aty = a[5];\n\n    var det = aa * ad - ab * ac;\n    if (!det) {\n        return null;\n    }\n    det = 1.0 / det;\n\n    out[0] = ad * det;\n    out[1] = -ab * det;\n    out[2] = -ac * det;\n    out[3] = aa * det;\n    out[4] = (ac * aty - ad * atx) * det;\n    out[5] = (ab * atx - aa * aty) * det;\n    return out;\n}\n\n/**\n * Clone a new matrix.\n * @param {Float32Array|Array.<number>} a\n */\nexport function clone(a) {\n    var b = create();\n    copy(b, a);\n    return b;\n}","/**\n * @module echarts/core/BoundingRect\n */\n\nimport * as vec2 from './vector';\nimport * as matrix from './matrix';\n\nvar v2ApplyTransform = vec2.applyTransform;\nvar mathMin = Math.min;\nvar mathMax = Math.max;\n\n/**\n * @alias module:echarts/core/BoundingRect\n */\nfunction BoundingRect(x, y, width, height) {\n\n    if (width < 0) {\n        x = x + width;\n        width = -width;\n    }\n    if (height < 0) {\n        y = y + height;\n        height = -height;\n    }\n\n    /**\n     * @type {number}\n     */\n    this.x = x;\n    /**\n     * @type {number}\n     */\n    this.y = y;\n    /**\n     * @type {number}\n     */\n    this.width = width;\n    /**\n     * @type {number}\n     */\n    this.height = height;\n}\n\nBoundingRect.prototype = {\n\n    constructor: BoundingRect,\n\n    /**\n     * @param {module:echarts/core/BoundingRect} other\n     */\n    union: function (other) {\n        var x = mathMin(other.x, this.x);\n        var y = mathMin(other.y, this.y);\n\n        this.width = mathMax(\n                other.x + other.width,\n                this.x + this.width\n            ) - x;\n        this.height = mathMax(\n                other.y + other.height,\n                this.y + this.height\n            ) - y;\n        this.x = x;\n        this.y = y;\n    },\n\n    /**\n     * @param {Array.<number>} m\n     * @methods\n     */\n    applyTransform: (function () {\n        var lt = [];\n        var rb = [];\n        var lb = [];\n        var rt = [];\n        return function (m) {\n            // In case usage like this\n            // el.getBoundingRect().applyTransform(el.transform)\n            // And element has no transform\n            if (!m) {\n                return;\n            }\n            lt[0] = lb[0] = this.x;\n            lt[1] = rt[1] = this.y;\n            rb[0] = rt[0] = this.x + this.width;\n            rb[1] = lb[1] = this.y + this.height;\n\n            v2ApplyTransform(lt, lt, m);\n            v2ApplyTransform(rb, rb, m);\n            v2ApplyTransform(lb, lb, m);\n            v2ApplyTransform(rt, rt, m);\n\n            this.x = mathMin(lt[0], rb[0], lb[0], rt[0]);\n            this.y = mathMin(lt[1], rb[1], lb[1], rt[1]);\n            var maxX = mathMax(lt[0], rb[0], lb[0], rt[0]);\n            var maxY = mathMax(lt[1], rb[1], lb[1], rt[1]);\n            this.width = maxX - this.x;\n            this.height = maxY - this.y;\n        };\n    })(),\n\n    /**\n     * Calculate matrix of transforming from self to target rect\n     * @param  {module:zrender/core/BoundingRect} b\n     * @return {Array.<number>}\n     */\n    calculateTransform: function (b) {\n        var a = this;\n        var sx = b.width / a.width;\n        var sy = b.height / a.height;\n\n        var m = matrix.create();\n\n        // 矩阵右乘\n        matrix.translate(m, m, [-a.x, -a.y]);\n        matrix.scale(m, m, [sx, sy]);\n        matrix.translate(m, m, [b.x, b.y]);\n\n        return m;\n    },\n\n    /**\n     * @param {(module:echarts/core/BoundingRect|Object)} b\n     * @return {boolean}\n     */\n    intersect: function (b) {\n        if (!b) {\n            return false;\n        }\n\n        if (!(b instanceof BoundingRect)) {\n            // Normalize negative width/height.\n            b = BoundingRect.create(b);\n        }\n\n        var a = this;\n        var ax0 = a.x;\n        var ax1 = a.x + a.width;\n        var ay0 = a.y;\n        var ay1 = a.y + a.height;\n\n        var bx0 = b.x;\n        var bx1 = b.x + b.width;\n        var by0 = b.y;\n        var by1 = b.y + b.height;\n\n        return !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);\n    },\n\n    contain: function (x, y) {\n        var rect = this;\n        return x >= rect.x\n            && x <= (rect.x + rect.width)\n            && y >= rect.y\n            && y <= (rect.y + rect.height);\n    },\n\n    /**\n     * @return {module:echarts/core/BoundingRect}\n     */\n    clone: function () {\n        return new BoundingRect(this.x, this.y, this.width, this.height);\n    },\n\n    /**\n     * Copy from another rect\n     */\n    copy: function (other) {\n        this.x = other.x;\n        this.y = other.y;\n        this.width = other.width;\n        this.height = other.height;\n    },\n\n    plain: function () {\n        return {\n            x: this.x,\n            y: this.y,\n            width: this.width,\n            height: this.height\n        };\n    }\n};\n\n/**\n * @param {Object|module:zrender/core/BoundingRect} rect\n * @param {number} rect.x\n * @param {number} rect.y\n * @param {number} rect.width\n * @param {number} rect.height\n * @return {module:zrender/core/BoundingRect}\n */\nBoundingRect.create = function (rect) {\n    return new BoundingRect(rect.x, rect.y, rect.width, rect.height);\n};\n\nexport default BoundingRect;","// Simple LRU cache use doubly linked list\n// @module zrender/core/LRU\n\n/**\n * Simple double linked list. Compared with array, it has O(1) remove operation.\n * @constructor\n */\nvar LinkedList = function () {\n\n    /**\n     * @type {module:zrender/core/LRU~Entry}\n     */\n    this.head = null;\n\n    /**\n     * @type {module:zrender/core/LRU~Entry}\n     */\n    this.tail = null;\n\n    this._len = 0;\n};\n\nvar linkedListProto = LinkedList.prototype;\n/**\n * Insert a new value at the tail\n * @param  {} val\n * @return {module:zrender/core/LRU~Entry}\n */\nlinkedListProto.insert = function (val) {\n    var entry = new Entry(val);\n    this.insertEntry(entry);\n    return entry;\n};\n\n/**\n * Insert an entry at the tail\n * @param  {module:zrender/core/LRU~Entry} entry\n */\nlinkedListProto.insertEntry = function (entry) {\n    if (!this.head) {\n        this.head = this.tail = entry;\n    }\n    else {\n        this.tail.next = entry;\n        entry.prev = this.tail;\n        entry.next = null;\n        this.tail = entry;\n    }\n    this._len++;\n};\n\n/**\n * Remove entry.\n * @param  {module:zrender/core/LRU~Entry} entry\n */\nlinkedListProto.remove = function (entry) {\n    var prev = entry.prev;\n    var next = entry.next;\n    if (prev) {\n        prev.next = next;\n    }\n    else {\n        // Is head\n        this.head = next;\n    }\n    if (next) {\n        next.prev = prev;\n    }\n    else {\n        // Is tail\n        this.tail = prev;\n    }\n    entry.next = entry.prev = null;\n    this._len--;\n};\n\n/**\n * @return {number}\n */\nlinkedListProto.len = function () {\n    return this._len;\n};\n\n/**\n * Clear list\n */\nlinkedListProto.clear = function () {\n    this.head = this.tail = null;\n    this._len = 0;\n};\n\n/**\n * @constructor\n * @param {} val\n */\nvar Entry = function (val) {\n    /**\n     * @type {}\n     */\n    this.value = val;\n\n    /**\n     * @type {module:zrender/core/LRU~Entry}\n     */\n    this.next;\n\n    /**\n     * @type {module:zrender/core/LRU~Entry}\n     */\n    this.prev;\n};\n\n/**\n * LRU Cache\n * @constructor\n * @alias module:zrender/core/LRU\n */\nvar LRU = function (maxSize) {\n\n    this._list = new LinkedList();\n\n    this._map = {};\n\n    this._maxSize = maxSize || 10;\n\n    this._lastRemovedEntry = null;\n};\n\nvar LRUProto = LRU.prototype;\n\n/**\n * @param  {string} key\n * @param  {} value\n * @return {} Removed value\n */\nLRUProto.put = function (key, value) {\n    var list = this._list;\n    var map = this._map;\n    var removed = null;\n    if (map[key] == null) {\n        var len = list.len();\n        // Reuse last removed entry\n        var entry = this._lastRemovedEntry;\n\n        if (len >= this._maxSize && len > 0) {\n            // Remove the least recently used\n            var leastUsedEntry = list.head;\n            list.remove(leastUsedEntry);\n            delete map[leastUsedEntry.key];\n\n            removed = leastUsedEntry.value;\n            this._lastRemovedEntry = leastUsedEntry;\n        }\n\n        if (entry) {\n            entry.value = value;\n        }\n        else {\n            entry = new Entry(value);\n        }\n        entry.key = key;\n        list.insertEntry(entry);\n        map[key] = entry;\n    }\n\n    return removed;\n};\n\n/**\n * @param  {string} key\n * @return {}\n */\nLRUProto.get = function (key) {\n    var entry = this._map[key];\n    var list = this._list;\n    if (entry != null) {\n        // Put the latest used entry in the tail\n        if (entry !== list.tail) {\n            list.remove(entry);\n            list.insertEntry(entry);\n        }\n\n        return entry.value;\n    }\n};\n\n/**\n * Clear the cache\n */\nLRUProto.clear = function () {\n    this._list.clear();\n    this._map = {};\n};\n\nexport default LRU;","\nimport LRU from '../../core/LRU';\n\nvar globalImageCache = new LRU(50);\n\n/**\n * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n */\nexport function findExistImage(newImageOrSrc) {\n    if (typeof newImageOrSrc === 'string') {\n        var cachedImgObj = globalImageCache.get(newImageOrSrc);\n        return cachedImgObj && cachedImgObj.image;\n    }\n    else {\n        return newImageOrSrc;\n    }\n}\n\n/**\n * Caution: User should cache loaded images, but not just count on LRU.\n * Consider if required images more than LRU size, will dead loop occur?\n *\n * @param {string|HTMLImageElement|HTMLCanvasElement|Canvas} newImageOrSrc\n * @param {HTMLImageElement|HTMLCanvasElement|Canvas} image Existent image.\n * @param {module:zrender/Element} [hostEl] For calling `dirty`.\n * @param {Function} [cb] params: (image, cbPayload)\n * @param {Object} [cbPayload] Payload on cb calling.\n * @return {HTMLImageElement|HTMLCanvasElement|Canvas} image\n */\nexport function createOrUpdateImage(newImageOrSrc, image, hostEl, cb, cbPayload) {\n    if (!newImageOrSrc) {\n        return image;\n    }\n    else if (typeof newImageOrSrc === 'string') {\n\n        // Image should not be loaded repeatly.\n        if ((image && image.__zrImageSrc === newImageOrSrc) || !hostEl) {\n            return image;\n        }\n\n        // Only when there is no existent image or existent image src\n        // is different, this method is responsible for load.\n        var cachedImgObj = globalImageCache.get(newImageOrSrc);\n\n        var pendingWrap = {hostEl: hostEl, cb: cb, cbPayload: cbPayload};\n\n        if (cachedImgObj) {\n            image = cachedImgObj.image;\n            !isImageReady(image) && cachedImgObj.pending.push(pendingWrap);\n        }\n        else {\n            image = new Image();\n            image.onload = image.onerror = imageOnLoad;\n\n            globalImageCache.put(\n                newImageOrSrc,\n                image.__cachedImgObj = {\n                    image: image,\n                    pending: [pendingWrap]\n                }\n            );\n\n            image.src = image.__zrImageSrc = newImageOrSrc;\n        }\n\n        return image;\n    }\n    // newImageOrSrc is an HTMLImageElement or HTMLCanvasElement or Canvas\n    else {\n        return newImageOrSrc;\n    }\n}\n\nfunction imageOnLoad() {\n    var cachedImgObj = this.__cachedImgObj;\n    this.onload = this.onerror = this.__cachedImgObj = null;\n\n    for (var i = 0; i < cachedImgObj.pending.length; i++) {\n        var pendingWrap = cachedImgObj.pending[i];\n        var cb = pendingWrap.cb;\n        cb && cb(this, pendingWrap.cbPayload);\n        pendingWrap.hostEl.dirty();\n    }\n    cachedImgObj.pending.length = 0;\n}\n\nexport function isImageReady(image) {\n    return image && image.width && image.height;\n}\n\n","import BoundingRect from '../core/BoundingRect';\nimport * as imageHelper from '../graphic/helper/image';\nimport {\n    getContext,\n    extend,\n    retrieve2,\n    retrieve3,\n    trim\n} from '../core/util';\n\nvar textWidthCache = {};\nvar textWidthCacheCounter = 0;\n\nvar TEXT_CACHE_MAX = 5000;\nvar STYLE_REG = /\\{([a-zA-Z0-9_]+)\\|([^}]*)\\}/g;\n\nexport var DEFAULT_FONT = '12px sans-serif';\n\n// Avoid assign to an exported variable, for transforming to cjs.\nvar methods = {};\n\nexport function $override(name, fn) {\n    methods[name] = fn;\n}\n\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @return {number} width\n */\nexport function getWidth(text, font) {\n    font = font || DEFAULT_FONT;\n    var key = text + ':' + font;\n    if (textWidthCache[key]) {\n        return textWidthCache[key];\n    }\n\n    var textLines = (text + '').split('\\n');\n    var width = 0;\n\n    for (var i = 0, l = textLines.length; i < l; i++) {\n        // textContain.measureText may be overrided in SVG or VML\n        width = Math.max(measureText(textLines[i], font).width, width);\n    }\n\n    if (textWidthCacheCounter > TEXT_CACHE_MAX) {\n        textWidthCacheCounter = 0;\n        textWidthCache = {};\n    }\n    textWidthCacheCounter++;\n    textWidthCache[key] = width;\n\n    return width;\n}\n\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @param {string} [textAlign='left']\n * @param {string} [textVerticalAlign='top']\n * @param {Array.<number>} [textPadding]\n * @param {Object} [rich]\n * @param {Object} [truncate]\n * @return {Object} {x, y, width, height, lineHeight}\n */\nexport function getBoundingRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) {\n    return rich\n        ? getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate)\n        : getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, truncate);\n}\n\nfunction getPlainTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, truncate) {\n    var contentBlock = parsePlainText(text, font, textPadding, textLineHeight, truncate);\n    var outerWidth = getWidth(text, font);\n    if (textPadding) {\n        outerWidth += textPadding[1] + textPadding[3];\n    }\n    var outerHeight = contentBlock.outerHeight;\n\n    var x = adjustTextX(0, outerWidth, textAlign);\n    var y = adjustTextY(0, outerHeight, textVerticalAlign);\n\n    var rect = new BoundingRect(x, y, outerWidth, outerHeight);\n    rect.lineHeight = contentBlock.lineHeight;\n\n    return rect;\n}\n\nfunction getRichTextRect(text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate) {\n    var contentBlock = parseRichText(text, {\n        rich: rich,\n        truncate: truncate,\n        font: font,\n        textAlign: textAlign,\n        textPadding: textPadding,\n        textLineHeight: textLineHeight\n    });\n    var outerWidth = contentBlock.outerWidth;\n    var outerHeight = contentBlock.outerHeight;\n\n    var x = adjustTextX(0, outerWidth, textAlign);\n    var y = adjustTextY(0, outerHeight, textVerticalAlign);\n\n    return new BoundingRect(x, y, outerWidth, outerHeight);\n}\n\n/**\n * @public\n * @param {number} x\n * @param {number} width\n * @param {string} [textAlign='left']\n * @return {number} Adjusted x.\n */\nexport function adjustTextX(x, width, textAlign) {\n    // FIXME Right to left language\n    if (textAlign === 'right') {\n        x -= width;\n    }\n    else if (textAlign === 'center') {\n        x -= width / 2;\n    }\n    return x;\n}\n\n/**\n * @public\n * @param {number} y\n * @param {number} height\n * @param {string} [textVerticalAlign='top']\n * @return {number} Adjusted y.\n */\nexport function adjustTextY(y, height, textVerticalAlign) {\n    if (textVerticalAlign === 'middle') {\n        y -= height / 2;\n    }\n    else if (textVerticalAlign === 'bottom') {\n        y -= height;\n    }\n    return y;\n}\n\n/**\n * Follow same interface to `Displayable.prototype.calculateTextPosition`.\n * @public\n * @param {Obejct} [out] Prepared out object. If not input, auto created in the method.\n * @param {module:zrender/graphic/Style} style where `textPosition` and `textDistance` are visited.\n * @param {Object} rect {x, y, width, height} Rect of the host elment, according to which the text positioned.\n * @return {Object} The input `out`. Set: {x, y, textAlign, textVerticalAlign}\n */\nexport function calculateTextPosition(out, style, rect) {\n    var textPosition = style.textPosition;\n    var distance = style.textDistance;\n\n    var x = rect.x;\n    var y = rect.y;\n    distance = distance || 0;\n\n    var height = rect.height;\n    var width = rect.width;\n    var halfHeight = height / 2;\n\n    var textAlign = 'left';\n    var textVerticalAlign = 'top';\n\n    switch (textPosition) {\n        case 'left':\n            x -= distance;\n            y += halfHeight;\n            textAlign = 'right';\n            textVerticalAlign = 'middle';\n            break;\n        case 'right':\n            x += distance + width;\n            y += halfHeight;\n            textVerticalAlign = 'middle';\n            break;\n        case 'top':\n            x += width / 2;\n            y -= distance;\n            textAlign = 'center';\n            textVerticalAlign = 'bottom';\n            break;\n        case 'bottom':\n            x += width / 2;\n            y += height + distance;\n            textAlign = 'center';\n            break;\n        case 'inside':\n            x += width / 2;\n            y += halfHeight;\n            textAlign = 'center';\n            textVerticalAlign = 'middle';\n            break;\n        case 'insideLeft':\n            x += distance;\n            y += halfHeight;\n            textVerticalAlign = 'middle';\n            break;\n        case 'insideRight':\n            x += width - distance;\n            y += halfHeight;\n            textAlign = 'right';\n            textVerticalAlign = 'middle';\n            break;\n        case 'insideTop':\n            x += width / 2;\n            y += distance;\n            textAlign = 'center';\n            break;\n        case 'insideBottom':\n            x += width / 2;\n            y += height - distance;\n            textAlign = 'center';\n            textVerticalAlign = 'bottom';\n            break;\n        case 'insideTopLeft':\n            x += distance;\n            y += distance;\n            break;\n        case 'insideTopRight':\n            x += width - distance;\n            y += distance;\n            textAlign = 'right';\n            break;\n        case 'insideBottomLeft':\n            x += distance;\n            y += height - distance;\n            textVerticalAlign = 'bottom';\n            break;\n        case 'insideBottomRight':\n            x += width - distance;\n            y += height - distance;\n            textAlign = 'right';\n            textVerticalAlign = 'bottom';\n            break;\n    }\n\n    out = out || {};\n    out.x = x;\n    out.y = y;\n    out.textAlign = textAlign;\n    out.textVerticalAlign = textVerticalAlign;\n\n    return out;\n}\n\n/**\n * To be removed. But still do not remove in case that some one has imported it.\n * @deprecated\n * @public\n * @param {stirng} textPosition\n * @param {Object} rect {x, y, width, height}\n * @param {number} distance\n * @return {Object} {x, y, textAlign, textVerticalAlign}\n */\nexport function adjustTextPositionOnRect(textPosition, rect, distance) {\n    var dummyStyle = {textPosition: textPosition, textDistance: distance};\n    return calculateTextPosition({}, dummyStyle, rect);\n}\n\n/**\n * Show ellipsis if overflow.\n *\n * @public\n * @param  {string} text\n * @param  {string} containerWidth\n * @param  {string} font\n * @param  {number} [ellipsis='...']\n * @param  {Object} [options]\n * @param  {number} [options.maxIterations=3]\n * @param  {number} [options.minChar=0] If truncate result are less\n *                  then minChar, ellipsis will not show, which is\n *                  better for user hint in some cases.\n * @param  {number} [options.placeholder=''] When all truncated, use the placeholder.\n * @return {string}\n */\nexport function truncateText(text, containerWidth, font, ellipsis, options) {\n    if (!containerWidth) {\n        return '';\n    }\n\n    var textLines = (text + '').split('\\n');\n    options = prepareTruncateOptions(containerWidth, font, ellipsis, options);\n\n    // FIXME\n    // It is not appropriate that every line has '...' when truncate multiple lines.\n    for (var i = 0, len = textLines.length; i < len; i++) {\n        textLines[i] = truncateSingleLine(textLines[i], options);\n    }\n\n    return textLines.join('\\n');\n}\n\nfunction prepareTruncateOptions(containerWidth, font, ellipsis, options) {\n    options = extend({}, options);\n\n    options.font = font;\n    var ellipsis = retrieve2(ellipsis, '...');\n    options.maxIterations = retrieve2(options.maxIterations, 2);\n    var minChar = options.minChar = retrieve2(options.minChar, 0);\n    // FIXME\n    // Other languages?\n    options.cnCharWidth = getWidth('国', font);\n    // FIXME\n    // Consider proportional font?\n    var ascCharWidth = options.ascCharWidth = getWidth('a', font);\n    options.placeholder = retrieve2(options.placeholder, '');\n\n    // Example 1: minChar: 3, text: 'asdfzxcv', truncate result: 'asdf', but not: 'a...'.\n    // Example 2: minChar: 3, text: '维度', truncate result: '维', but not: '...'.\n    var contentWidth = containerWidth = Math.max(0, containerWidth - 1); // Reserve some gap.\n    for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {\n        contentWidth -= ascCharWidth;\n    }\n\n    var ellipsisWidth = getWidth(ellipsis, font);\n    if (ellipsisWidth > contentWidth) {\n        ellipsis = '';\n        ellipsisWidth = 0;\n    }\n\n    contentWidth = containerWidth - ellipsisWidth;\n\n    options.ellipsis = ellipsis;\n    options.ellipsisWidth = ellipsisWidth;\n    options.contentWidth = contentWidth;\n    options.containerWidth = containerWidth;\n\n    return options;\n}\n\nfunction truncateSingleLine(textLine, options) {\n    var containerWidth = options.containerWidth;\n    var font = options.font;\n    var contentWidth = options.contentWidth;\n\n    if (!containerWidth) {\n        return '';\n    }\n\n    var lineWidth = getWidth(textLine, font);\n\n    if (lineWidth <= containerWidth) {\n        return textLine;\n    }\n\n    for (var j = 0; ; j++) {\n        if (lineWidth <= contentWidth || j >= options.maxIterations) {\n            textLine += options.ellipsis;\n            break;\n        }\n\n        var subLength = j === 0\n            ? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth)\n            : lineWidth > 0\n            ? Math.floor(textLine.length * contentWidth / lineWidth)\n            : 0;\n\n        textLine = textLine.substr(0, subLength);\n        lineWidth = getWidth(textLine, font);\n    }\n\n    if (textLine === '') {\n        textLine = options.placeholder;\n    }\n\n    return textLine;\n}\n\nfunction estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {\n    var width = 0;\n    var i = 0;\n    for (var len = text.length; i < len && width < contentWidth; i++) {\n        var charCode = text.charCodeAt(i);\n        width += (0 <= charCode && charCode <= 127) ? ascCharWidth : cnCharWidth;\n    }\n    return i;\n}\n\n/**\n * @public\n * @param {string} font\n * @return {number} line height\n */\nexport function getLineHeight(font) {\n    // FIXME A rough approach.\n    return getWidth('国', font);\n}\n\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @return {Object} width\n */\nexport function measureText(text, font) {\n    return methods.measureText(text, font);\n}\n\n// Avoid assign to an exported variable, for transforming to cjs.\nmethods.measureText = function (text, font) {\n    var ctx = getContext();\n    ctx.font = font || DEFAULT_FONT;\n    return ctx.measureText(text);\n};\n\n/**\n * @public\n * @param {string} text\n * @param {string} font\n * @param {Object} [truncate]\n * @return {Object} block: {lineHeight, lines, height, outerHeight, canCacheByTextString}\n *  Notice: for performance, do not calculate outerWidth util needed.\n *  `canCacheByTextString` means the result `lines` is only determined by the input `text`.\n *  Thus we can simply comparing the `input` text to determin whether the result changed,\n *  without travel the result `lines`.\n */\nexport function parsePlainText(text, font, padding, textLineHeight, truncate) {\n    text != null && (text += '');\n\n    var lineHeight = retrieve2(textLineHeight, getLineHeight(font));\n    var lines = text ? text.split('\\n') : [];\n    var height = lines.length * lineHeight;\n    var outerHeight = height;\n    var canCacheByTextString = true;\n\n    if (padding) {\n        outerHeight += padding[0] + padding[2];\n    }\n\n    if (text && truncate) {\n        canCacheByTextString = false;\n        var truncOuterHeight = truncate.outerHeight;\n        var truncOuterWidth = truncate.outerWidth;\n        if (truncOuterHeight != null && outerHeight > truncOuterHeight) {\n            text = '';\n            lines = [];\n        }\n        else if (truncOuterWidth != null) {\n            var options = prepareTruncateOptions(\n                truncOuterWidth - (padding ? padding[1] + padding[3] : 0),\n                font,\n                truncate.ellipsis,\n                {minChar: truncate.minChar, placeholder: truncate.placeholder}\n            );\n\n            // FIXME\n            // It is not appropriate that every line has '...' when truncate multiple lines.\n            for (var i = 0, len = lines.length; i < len; i++) {\n                lines[i] = truncateSingleLine(lines[i], options);\n            }\n        }\n    }\n\n    return {\n        lines: lines,\n        height: height,\n        outerHeight: outerHeight,\n        lineHeight: lineHeight,\n        canCacheByTextString: canCacheByTextString\n    };\n}\n\n/**\n * For example: 'some text {a|some text}other text{b|some text}xxx{c|}xxx'\n * Also consider 'bbbb{a|xxx\\nzzz}xxxx\\naaaa'.\n *\n * @public\n * @param {string} text\n * @param {Object} style\n * @return {Object} block\n * {\n *      width,\n *      height,\n *      lines: [{\n *          lineHeight,\n *          width,\n *          tokens: [[{\n *              styleName,\n *              text,\n *              width,      // include textPadding\n *              height,     // include textPadding\n *              textWidth, // pure text width\n *              textHeight, // pure text height\n *              lineHeihgt,\n *              font,\n *              textAlign,\n *              textVerticalAlign\n *          }], [...], ...]\n *      }, ...]\n * }\n * If styleName is undefined, it is plain text.\n */\nexport function parseRichText(text, style) {\n    var contentBlock = {lines: [], width: 0, height: 0};\n\n    text != null && (text += '');\n    if (!text) {\n        return contentBlock;\n    }\n\n    var lastIndex = STYLE_REG.lastIndex = 0;\n    var result;\n    while ((result = STYLE_REG.exec(text)) != null) {\n        var matchedIndex = result.index;\n        if (matchedIndex > lastIndex) {\n            pushTokens(contentBlock, text.substring(lastIndex, matchedIndex));\n        }\n        pushTokens(contentBlock, result[2], result[1]);\n        lastIndex = STYLE_REG.lastIndex;\n    }\n\n    if (lastIndex < text.length) {\n        pushTokens(contentBlock, text.substring(lastIndex, text.length));\n    }\n\n    var lines = contentBlock.lines;\n    var contentHeight = 0;\n    var contentWidth = 0;\n    // For `textWidth: 100%`\n    var pendingList = [];\n\n    var stlPadding = style.textPadding;\n\n    var truncate = style.truncate;\n    var truncateWidth = truncate && truncate.outerWidth;\n    var truncateHeight = truncate && truncate.outerHeight;\n    if (stlPadding) {\n        truncateWidth != null && (truncateWidth -= stlPadding[1] + stlPadding[3]);\n        truncateHeight != null && (truncateHeight -= stlPadding[0] + stlPadding[2]);\n    }\n\n    // Calculate layout info of tokens.\n    for (var i = 0; i < lines.length; i++) {\n        var line = lines[i];\n        var lineHeight = 0;\n        var lineWidth = 0;\n\n        for (var j = 0; j < line.tokens.length; j++) {\n            var token = line.tokens[j];\n            var tokenStyle = token.styleName && style.rich[token.styleName] || {};\n            // textPadding should not inherit from style.\n            var textPadding = token.textPadding = tokenStyle.textPadding;\n\n            // textFont has been asigned to font by `normalizeStyle`.\n            var font = token.font = tokenStyle.font || style.font;\n\n            // textHeight can be used when textVerticalAlign is specified in token.\n            var tokenHeight = token.textHeight = retrieve2(\n                // textHeight should not be inherited, consider it can be specified\n                // as box height of the block.\n                tokenStyle.textHeight, getLineHeight(font)\n            );\n            textPadding && (tokenHeight += textPadding[0] + textPadding[2]);\n            token.height = tokenHeight;\n            token.lineHeight = retrieve3(\n                tokenStyle.textLineHeight, style.textLineHeight, tokenHeight\n            );\n\n            token.textAlign = tokenStyle && tokenStyle.textAlign || style.textAlign;\n            token.textVerticalAlign = tokenStyle && tokenStyle.textVerticalAlign || 'middle';\n\n            if (truncateHeight != null && contentHeight + token.lineHeight > truncateHeight) {\n                return {lines: [], width: 0, height: 0};\n            }\n\n            token.textWidth = getWidth(token.text, font);\n            var tokenWidth = tokenStyle.textWidth;\n            var tokenWidthNotSpecified = tokenWidth == null || tokenWidth === 'auto';\n\n            // Percent width, can be `100%`, can be used in drawing separate\n            // line when box width is needed to be auto.\n            if (typeof tokenWidth === 'string' && tokenWidth.charAt(tokenWidth.length - 1) === '%') {\n                token.percentWidth = tokenWidth;\n                pendingList.push(token);\n                tokenWidth = 0;\n                // Do not truncate in this case, because there is no user case\n                // and it is too complicated.\n            }\n            else {\n                if (tokenWidthNotSpecified) {\n                    tokenWidth = token.textWidth;\n\n                    // FIXME: If image is not loaded and textWidth is not specified, calling\n                    // `getBoundingRect()` will not get correct result.\n                    var textBackgroundColor = tokenStyle.textBackgroundColor;\n                    var bgImg = textBackgroundColor && textBackgroundColor.image;\n\n                    // Use cases:\n                    // (1) If image is not loaded, it will be loaded at render phase and call\n                    // `dirty()` and `textBackgroundColor.image` will be replaced with the loaded\n                    // image, and then the right size will be calculated here at the next tick.\n                    // See `graphic/helper/text.js`.\n                    // (2) If image loaded, and `textBackgroundColor.image` is image src string,\n                    // use `imageHelper.findExistImage` to find cached image.\n                    // `imageHelper.findExistImage` will always be called here before\n                    // `imageHelper.createOrUpdateImage` in `graphic/helper/text.js#renderRichText`\n                    // which ensures that image will not be rendered before correct size calcualted.\n                    if (bgImg) {\n                        bgImg = imageHelper.findExistImage(bgImg);\n                        if (imageHelper.isImageReady(bgImg)) {\n                            tokenWidth = Math.max(tokenWidth, bgImg.width * tokenHeight / bgImg.height);\n                        }\n                    }\n                }\n\n                var paddingW = textPadding ? textPadding[1] + textPadding[3] : 0;\n                tokenWidth += paddingW;\n\n                var remianTruncWidth = truncateWidth != null ? truncateWidth - lineWidth : null;\n\n                if (remianTruncWidth != null && remianTruncWidth < tokenWidth) {\n                    if (!tokenWidthNotSpecified || remianTruncWidth < paddingW) {\n                        token.text = '';\n                        token.textWidth = tokenWidth = 0;\n                    }\n                    else {\n                        token.text = truncateText(\n                            token.text, remianTruncWidth - paddingW, font, truncate.ellipsis,\n                            {minChar: truncate.minChar}\n                        );\n                        token.textWidth = getWidth(token.text, font);\n                        tokenWidth = token.textWidth + paddingW;\n                    }\n                }\n            }\n\n            lineWidth += (token.width = tokenWidth);\n            tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));\n        }\n\n        line.width = lineWidth;\n        line.lineHeight = lineHeight;\n        contentHeight += lineHeight;\n        contentWidth = Math.max(contentWidth, lineWidth);\n    }\n\n    contentBlock.outerWidth = contentBlock.width = retrieve2(style.textWidth, contentWidth);\n    contentBlock.outerHeight = contentBlock.height = retrieve2(style.textHeight, contentHeight);\n\n    if (stlPadding) {\n        contentBlock.outerWidth += stlPadding[1] + stlPadding[3];\n        contentBlock.outerHeight += stlPadding[0] + stlPadding[2];\n    }\n\n    for (var i = 0; i < pendingList.length; i++) {\n        var token = pendingList[i];\n        var percentWidth = token.percentWidth;\n        // Should not base on outerWidth, because token can not be placed out of padding.\n        token.width = parseInt(percentWidth, 10) / 100 * contentWidth;\n    }\n\n    return contentBlock;\n}\n\nfunction pushTokens(block, str, styleName) {\n    var isEmptyStr = str === '';\n    var strs = str.split('\\n');\n    var lines = block.lines;\n\n    for (var i = 0; i < strs.length; i++) {\n        var text = strs[i];\n        var token = {\n            styleName: styleName,\n            text: text,\n            isLineHolder: !text && !isEmptyStr\n        };\n\n        // The first token should be appended to the last line.\n        if (!i) {\n            var tokens = (lines[lines.length - 1] || (lines[0] = {tokens: []})).tokens;\n\n            // Consider cases:\n            // (1) ''.split('\\n') => ['', '\\n', ''], the '' at the first item\n            // (which is a placeholder) should be replaced by new token.\n            // (2) A image backage, where token likes {a|}.\n            // (3) A redundant '' will affect textAlign in line.\n            // (4) tokens with the same tplName should not be merged, because\n            // they should be displayed in different box (with border and padding).\n            var tokensLen = tokens.length;\n            (tokensLen === 1 && tokens[0].isLineHolder)\n                ? (tokens[0] = token)\n                // Consider text is '', only insert when it is the \"lineHolder\" or\n                // \"emptyStr\". Otherwise a redundant '' will affect textAlign in line.\n                : ((text || !tokensLen || isEmptyStr) && tokens.push(token));\n        }\n        // Other tokens always start a new line.\n        else {\n            // If there is '', insert it as a placeholder.\n            lines.push({tokens: [token]});\n        }\n    }\n}\n\nexport function makeFont(style) {\n    // FIXME in node-canvas fontWeight is before fontStyle\n    // Use `fontSize` `fontFamily` to check whether font properties are defined.\n    var font = (style.fontSize || style.fontFamily) && [\n        style.fontStyle,\n        style.fontWeight,\n        (style.fontSize || 12) + 'px',\n        // If font properties are defined, `fontFamily` should not be ignored.\n        style.fontFamily || 'sans-serif'\n    ].join(' ');\n    return font && trim(font) || style.textFont || style.font;\n}\n","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nimport * as zrUtil from 'zrender/src/core/util';\nimport * as textContain from 'zrender/src/contain/text';\nimport * as numberUtil from './number';\n// import Text from 'zrender/src/graphic/Text';\n\n/**\n * add commas after every three numbers\n * @param {string|number} x\n * @return {string}\n */\nexport function addCommas(x) {\n    if (isNaN(x)) {\n        return '-';\n    }\n    x = (x + '').split('.');\n    return x[0].replace(/(\\d{1,3})(?=(?:\\d{3})+(?!\\d))/g, '$1,')\n            + (x.length > 1 ? ('.' + x[1]) : '');\n}\n\n/**\n * @param {string} str\n * @param {boolean} [upperCaseFirst=false]\n * @return {string} str\n */\nexport function toCamelCase(str, upperCaseFirst) {\n    str = (str || '').toLowerCase().replace(/-(.)/g, function (match, group1) {\n        return group1.toUpperCase();\n    });\n\n    if (upperCaseFirst && str) {\n        str = str.charAt(0).toUpperCase() + str.slice(1);\n    }\n\n    return str;\n}\n\nexport var normalizeCssArray = zrUtil.normalizeCssArray;\n\n\nvar replaceReg = /([&<>\"'])/g;\nvar replaceMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    '\\'': '&#39;'\n};\n\nexport function encodeHTML(source) {\n    return source == null\n        ? ''\n        : (source + '').replace(replaceReg, function (str, c) {\n            return replaceMap[c];\n        });\n}\n\nvar TPL_VAR_ALIAS = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];\n\nvar wrapVar = function (varName, seriesIdx) {\n    return '{' + varName + (seriesIdx == null ? '' : seriesIdx) + '}';\n};\n\n/**\n * Template formatter\n * @param {string} tpl\n * @param {Array.<Object>|Object} paramsList\n * @param {boolean} [encode=false]\n * @return {string}\n */\nexport function formatTpl(tpl, paramsList, encode) {\n    if (!zrUtil.isArray(paramsList)) {\n        paramsList = [paramsList];\n    }\n    var seriesLen = paramsList.length;\n    if (!seriesLen) {\n        return '';\n    }\n\n    var $vars = paramsList[0].$vars || [];\n    for (var i = 0; i < $vars.length; i++) {\n        var alias = TPL_VAR_ALIAS[i];\n        tpl = tpl.replace(wrapVar(alias), wrapVar(alias, 0));\n    }\n    for (var seriesIdx = 0; seriesIdx < seriesLen; seriesIdx++) {\n        for (var k = 0; k < $vars.length; k++) {\n            var val = paramsList[seriesIdx][$vars[k]];\n            tpl = tpl.replace(\n                wrapVar(TPL_VAR_ALIAS[k], seriesIdx),\n                encode ? encodeHTML(val) : val\n            );\n        }\n    }\n\n    return tpl;\n}\n\n/**\n * simple Template formatter\n *\n * @param {string} tpl\n * @param {Object} param\n * @param {boolean} [encode=false]\n * @return {string}\n */\nexport function formatTplSimple(tpl, param, encode) {\n    zrUtil.each(param, function (value, key) {\n        tpl = tpl.replace(\n            '{' + key + '}',\n            encode ? encodeHTML(value) : value\n        );\n    });\n    return tpl;\n}\n\n/**\n * @param {Object|string} [opt] If string, means color.\n * @param {string} [opt.color]\n * @param {string} [opt.extraCssText]\n * @param {string} [opt.type='item'] 'item' or 'subItem'\n * @param {string} [opt.renderMode='html'] render mode of tooltip, 'html' or 'richText'\n * @param {string} [opt.markerId='X'] id name for marker. If only one marker is in a rich text, this can be omitted.\n * @return {string}\n */\nexport function getTooltipMarker(opt, extraCssText) {\n    opt = zrUtil.isString(opt) ? {color: opt, extraCssText: extraCssText} : (opt || {});\n    var color = opt.color;\n    var type = opt.type;\n    var extraCssText = opt.extraCssText;\n    var renderMode = opt.renderMode || 'html';\n    var markerId = opt.markerId || 'X';\n\n    if (!color) {\n        return '';\n    }\n\n    if (renderMode === 'html') {\n        return type === 'subItem'\n        ? '<span style=\"display:inline-block;vertical-align:middle;margin-right:8px;margin-left:3px;'\n            + 'border-radius:4px;width:4px;height:4px;background-color:'\n            + encodeHTML(color) + ';' + (extraCssText || '') + '\"></span>'\n        : '<span style=\"display:inline-block;margin-right:5px;'\n            + 'border-radius:10px;width:10px;height:10px;background-color:'\n            + encodeHTML(color) + ';' + (extraCssText || '') + '\"></span>';\n    }\n    else {\n        // Space for rich element marker\n        return {\n            renderMode: renderMode,\n            content: '{marker' + markerId + '|}  ',\n            style: {\n                color: color\n            }\n        };\n    }\n}\n\nfunction pad(str, len) {\n    str += '';\n    return '0000'.substr(0, len - str.length) + str;\n}\n\n\n/**\n * ISO Date format\n * @param {string} tpl\n * @param {number} value\n * @param {boolean} [isUTC=false] Default in local time.\n *           see `module:echarts/scale/Time`\n *           and `module:echarts/util/number#parseDate`.\n * @inner\n */\nexport function formatTime(tpl, value, isUTC) {\n    if (tpl === 'week'\n        || tpl === 'month'\n        || tpl === 'quarter'\n        || tpl === 'half-year'\n        || tpl === 'year'\n    ) {\n        tpl = 'MM-dd\\nyyyy';\n    }\n\n    var date = numberUtil.parseDate(value);\n    var utc = isUTC ? 'UTC' : '';\n    var y = date['get' + utc + 'FullYear']();\n    var M = date['get' + utc + 'Month']() + 1;\n    var d = date['get' + utc + 'Date']();\n    var h = date['get' + utc + 'Hours']();\n    var m = date['get' + utc + 'Minutes']();\n    var s = date['get' + utc + 'Seconds']();\n    var S = date['get' + utc + 'Milliseconds']();\n\n    tpl = tpl.replace('MM', pad(M, 2))\n        .replace('M', M)\n        .replace('yyyy', y)\n        .replace('yy', y % 100)\n        .replace('dd', pad(d, 2))\n        .replace('d', d)\n        .replace('hh', pad(h, 2))\n        .replace('h', h)\n        .replace('mm', pad(m, 2))\n        .replace('m', m)\n        .replace('ss', pad(s, 2))\n        .replace('s', s)\n        .replace('SSS', pad(S, 3));\n\n    return tpl;\n}\n\n/**\n * Capital first\n * @param {string} str\n * @return {string}\n */\nexport function capitalFirst(str) {\n    return str ? str.charAt(0).toUpperCase() + str.substr(1) : str;\n}\n\nexport var truncateText = textContain.truncateText;\n\n/**\n * @public\n * @param {Object} opt\n * @param {string} opt.text\n * @param {string} opt.font\n * @param {string} [opt.textAlign='left']\n * @param {string} [opt.textVerticalAlign='top']\n * @param {Array.<number>} [opt.textPadding]\n * @param {number} [opt.textLineHeight]\n * @param {Object} [opt.rich]\n * @param {Object} [opt.truncate]\n * @return {Object} {x, y, width, height, lineHeight}\n */\nexport function getTextBoundingRect(opt) {\n    return textContain.getBoundingRect(\n        opt.text,\n        opt.font,\n        opt.textAlign,\n        opt.textVerticalAlign,\n        opt.textPadding,\n        opt.textLineHeight,\n        opt.rich,\n        opt.truncate\n    );\n}\n\n/**\n * @deprecated\n * the `textLineHeight` was added later.\n * For backward compatiblility, put it as the last parameter.\n * But deprecated this interface. Please use `getTextBoundingRect` instead.\n */\nexport function getTextRect(\n    text, font, textAlign, textVerticalAlign, textPadding, rich, truncate, textLineHeight\n) {\n    return textContain.getBoundingRect(\n        text, font, textAlign, textVerticalAlign, textPadding, textLineHeight, rich, truncate\n    );\n}\n\n/**\n * open new tab\n * @param {string} link url\n * @param {string} target blank or self\n */\nexport function windowOpen(link, target) {\n    if (target === '_blank' || target === 'blank') {\n        var blank = window.open();\n        blank.opener = null;\n        blank.location = link;\n    }\n    else {\n        window.open(link, target);\n    }\n}\n","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * For testable.\n */\n\nimport * as numberUtil from '../util/number';\n\nvar roundNumber = numberUtil.round;\n\n/**\n * @param {Array.<number>} extent Both extent[0] and extent[1] should be valid number.\n *                                Should be extent[0] < extent[1].\n * @param {number} splitNumber splitNumber should be >= 1.\n * @param {number} [minInterval]\n * @param {number} [maxInterval]\n * @return {Object} {interval, intervalPrecision, niceTickExtent}\n */\nexport function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) {\n    var result = {};\n    var span = extent[1] - extent[0];\n\n    var interval = result.interval = numberUtil.nice(span / splitNumber, true);\n    if (minInterval != null && interval < minInterval) {\n        interval = result.interval = minInterval;\n    }\n    if (maxInterval != null && interval > maxInterval) {\n        interval = result.interval = maxInterval;\n    }\n    // Tow more digital for tick.\n    var precision = result.intervalPrecision = getIntervalPrecision(interval);\n    // Niced extent inside original extent\n    var niceTickExtent = result.niceTickExtent = [\n        roundNumber(Math.ceil(extent[0] / interval) * interval, precision),\n        roundNumber(Math.floor(extent[1] / interval) * interval, precision)\n    ];\n\n    fixExtent(niceTickExtent, extent);\n\n    return result;\n}\n\n/**\n * @param {number} interval\n * @return {number} interval precision\n */\nexport function getIntervalPrecision(interval) {\n    // Tow more digital for tick.\n    return numberUtil.getPrecisionSafe(interval) + 2;\n}\n\nfunction clamp(niceTickExtent, idx, extent) {\n    niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);\n}\n\n// In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent.\nexport function fixExtent(niceTickExtent, extent) {\n    !isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);\n    !isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);\n    clamp(niceTickExtent, 0, extent);\n    clamp(niceTickExtent, 1, extent);\n    if (niceTickExtent[0] > niceTickExtent[1]) {\n        niceTickExtent[0] = niceTickExtent[1];\n    }\n}","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Interval scale\n * @module echarts/scale/Interval\n */\n\n\nimport * as numberUtil from '../util/number';\nimport * as formatUtil from '../util/format';\nimport Scale from './Scale';\nimport * as helper from './helper';\n\nvar roundNumber = numberUtil.round;\n\n/**\n * @alias module:echarts/coord/scale/Interval\n * @constructor\n */\nvar IntervalScale = Scale.extend({\n\n    type: 'interval',\n\n    _interval: 0,\n\n    _intervalPrecision: 2,\n\n    setExtent: function (start, end) {\n        var thisExtent = this._extent;\n        //start,end may be a Number like '25',so...\n        if (!isNaN(start)) {\n            thisExtent[0] = parseFloat(start);\n        }\n        if (!isNaN(end)) {\n            thisExtent[1] = parseFloat(end);\n        }\n    },\n\n    unionExtent: function (other) {\n        var extent = this._extent;\n        other[0] < extent[0] && (extent[0] = other[0]);\n        other[1] > extent[1] && (extent[1] = other[1]);\n\n        // unionExtent may called by it's sub classes\n        IntervalScale.prototype.setExtent.call(this, extent[0], extent[1]);\n    },\n    /**\n     * Get interval\n     */\n    getInterval: function () {\n        return this._interval;\n    },\n\n    /**\n     * Set interval\n     */\n    setInterval: function (interval) {\n        this._interval = interval;\n        // Dropped auto calculated niceExtent and use user setted extent\n        // We assume user wan't to set both interval, min, max to get a better result\n        this._niceExtent = this._extent.slice();\n\n        this._intervalPrecision = helper.getIntervalPrecision(interval);\n    },\n\n    /**\n     * @param {boolean} [expandToNicedExtent=false] If expand the ticks to niced extent.\n     * @return {Array.<number>}\n     */\n    getTicks: function (expandToNicedExtent) {\n        var interval = this._interval;\n        var extent = this._extent;\n        var niceTickExtent = this._niceExtent;\n        var intervalPrecision = this._intervalPrecision;\n\n        var ticks = [];\n        // If interval is 0, return [];\n        if (!interval) {\n            return ticks;\n        }\n\n        // Consider this case: using dataZoom toolbox, zoom and zoom.\n        var safeLimit = 10000;\n\n        if (extent[0] < niceTickExtent[0]) {\n            if (expandToNicedExtent) {\n                ticks.push(roundNumber(niceTickExtent[0] - interval, intervalPrecision));\n            }\n            else {\n                ticks.push(extent[0]);\n            }\n        }\n        var tick = niceTickExtent[0];\n\n        while (tick <= niceTickExtent[1]) {\n            ticks.push(tick);\n            // Avoid rounding error\n            tick = roundNumber(tick + interval, intervalPrecision);\n            if (tick === ticks[ticks.length - 1]) {\n                // Consider out of safe float point, e.g.,\n                // -3711126.9907707 + 2e-10 === -3711126.9907707\n                break;\n            }\n            if (ticks.length > safeLimit) {\n                return [];\n            }\n        }\n        // Consider this case: the last item of ticks is smaller\n        // than niceTickExtent[1] and niceTickExtent[1] === extent[1].\n        var lastNiceTick = ticks.length ? ticks[ticks.length - 1] : niceTickExtent[1];\n        if (extent[1] > lastNiceTick) {\n            if (expandToNicedExtent) {\n                ticks.push(roundNumber(lastNiceTick + interval, intervalPrecision));\n            }\n            else {\n                ticks.push(extent[1]);\n            }\n        }\n\n        return ticks;\n    },\n\n    /**\n     * @param {number} [splitNumber=5]\n     * @return {Array.<Array.<number>>}\n     */\n    getMinorTicks: function (splitNumber) {\n        var ticks = this.getTicks(true);\n        var minorTicks = [];\n        var extent = this.getExtent();\n\n        for (var i = 1; i < ticks.length; i++) {\n            var nextTick = ticks[i];\n            var prevTick = ticks[i - 1];\n            var count = 0;\n            var minorTicksGroup = [];\n            var interval = nextTick - prevTick;\n            var minorInterval = interval / splitNumber;\n\n            while (count < splitNumber - 1) {\n                var minorTick = numberUtil.round(prevTick + (count + 1) * minorInterval);\n\n                // For the first and last interval. The count may be less than splitNumber.\n                if (minorTick > extent[0] && minorTick < extent[1]) {\n                    minorTicksGroup.push(minorTick);\n                }\n                count++;\n            }\n            minorTicks.push(minorTicksGroup);\n        }\n\n        return minorTicks;\n    },\n\n    /**\n     * @param {number} data\n     * @param {Object} [opt]\n     * @param {number|string} [opt.precision] If 'auto', use nice presision.\n     * @param {boolean} [opt.pad] returns 1.50 but not 1.5 if precision is 2.\n     * @return {string}\n     */\n    getLabel: function (data, opt) {\n        if (data == null) {\n            return '';\n        }\n\n        var precision = opt && opt.precision;\n\n        if (precision == null) {\n            precision = numberUtil.getPrecisionSafe(data) || 0;\n        }\n        else if (precision === 'auto') {\n            // Should be more precise then tick.\n            precision = this._intervalPrecision;\n        }\n\n        // (1) If `precision` is set, 12.005 should be display as '12.00500'.\n        // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.\n        data = roundNumber(data, precision, true);\n\n        return formatUtil.addCommas(data);\n    },\n\n    /**\n     * Update interval and extent of intervals for nice ticks\n     *\n     * @param {number} [splitNumber = 5] Desired number of ticks\n     * @param {number} [minInterval]\n     * @param {number} [maxInterval]\n     */\n    niceTicks: function (splitNumber, minInterval, maxInterval) {\n        splitNumber = splitNumber || 5;\n        var extent = this._extent;\n        var span = extent[1] - extent[0];\n        if (!isFinite(span)) {\n            return;\n        }\n        // User may set axis min 0 and data are all negative\n        // FIXME If it needs to reverse ?\n        if (span < 0) {\n            span = -span;\n            extent.reverse();\n        }\n\n        var result = helper.intervalScaleNiceTicks(\n            extent, splitNumber, minInterval, maxInterval\n        );\n\n        this._intervalPrecision = result.intervalPrecision;\n        this._interval = result.interval;\n        this._niceExtent = result.niceTickExtent;\n    },\n\n    /**\n     * Nice extent.\n     * @param {Object} opt\n     * @param {number} [opt.splitNumber = 5] Given approx tick number\n     * @param {boolean} [opt.fixMin=false]\n     * @param {boolean} [opt.fixMax=false]\n     * @param {boolean} [opt.minInterval]\n     * @param {boolean} [opt.maxInterval]\n     */\n    niceExtent: function (opt) {\n        var extent = this._extent;\n        // If extent start and end are same, expand them\n        if (extent[0] === extent[1]) {\n            if (extent[0] !== 0) {\n                // Expand extent\n                var expandSize = extent[0];\n                // In the fowllowing case\n                //      Axis has been fixed max 100\n                //      Plus data are all 100 and axis extent are [100, 100].\n                // Extend to the both side will cause expanded max is larger than fixed max.\n                // So only expand to the smaller side.\n                if (!opt.fixMax) {\n                    extent[1] += expandSize / 2;\n                    extent[0] -= expandSize / 2;\n                }\n                else {\n                    extent[0] -= expandSize / 2;\n                }\n            }\n            else {\n                extent[1] = 1;\n            }\n        }\n        var span = extent[1] - extent[0];\n        // If there are no data and extent are [Infinity, -Infinity]\n        if (!isFinite(span)) {\n            extent[0] = 0;\n            extent[1] = 1;\n        }\n\n        this.niceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);\n\n        // var extent = this._extent;\n        var interval = this._interval;\n\n        if (!opt.fixMin) {\n            extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);\n        }\n        if (!opt.fixMax) {\n            extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);\n        }\n    }\n});\n\n/**\n * @return {module:echarts/scale/Time}\n */\nIntervalScale.create = function () {\n    return new IntervalScale();\n};\n\nexport default IntervalScale;","/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Log scale\n * @module echarts/scale/Log\n */\n\nimport * as zrUtil from 'zrender/src/core/util';\nimport Scale from './Scale';\nimport * as numberUtil from '../util/number';\n\n// Use some method of IntervalScale\nimport IntervalScale from './Interval';\n\nvar scaleProto = Scale.prototype;\nvar intervalScaleProto = IntervalScale.prototype;\n\nvar getPrecisionSafe = numberUtil.getPrecisionSafe;\nvar roundingErrorFix = numberUtil.round;\n\nvar mathFloor = Math.floor;\nvar mathCeil = Math.ceil;\nvar mathPow = Math.pow;\n\nvar mathLog = Math.log;\n\nvar LogScale = Scale.extend({\n\n    type: 'log',\n\n    base: 10,\n\n    $constructor: function () {\n        Scale.apply(this, arguments);\n        this._originalScale = new IntervalScale();\n    },\n\n    /**\n     * @param {boolean} [expandToNicedExtent=false] If expand the ticks to niced extent.\n     * @return {Array.<number>}\n     */\n    getTicks: function (expandToNicedExtent) {\n        var originalScale = this._originalScale;\n        var extent = this._extent;\n        var originalExtent = originalScale.getExtent();\n\n        return zrUtil.map(intervalScaleProto.getTicks.call(this, expandToNicedExtent), function (val) {\n            var powVal = numberUtil.round(mathPow(this.base, val));\n\n            // Fix #4158\n            powVal = (val === extent[0] && originalScale.__fixMin)\n                ? fixRoundingError(powVal, originalExtent[0])\n                : powVal;\n            powVal = (val === extent[1] && originalScale.__fixMax)\n                ? fixRoundingError(powVal, originalExtent[1])\n                : powVal;\n\n            return powVal;\n        }, this);\n    },\n\n    /**\n     * @param {number} splitNumber\n     * @return {Array.<Array.<number>>}\n     */\n    getMinorTicks: intervalScaleProto.getMinorTicks,\n\n    /**\n     * @param {number} val\n     * @return {string}\n     */\n    getLabel: intervalScaleProto.getLabel,\n\n    /**\n     * @param  {number} val\n     * @return {number}\n     */\n    scale: function (val) {\n        val = scaleProto.scale.call(this, val);\n        return mathPow(this.base, val);\n    },\n\n    /**\n     * @param {number} start\n     * @param {number} end\n     */\n    setExtent: function (start, end) {\n        var base = this.base;\n        start = mathLog(start) / mathLog(base);\n        end = mathLog(end) / mathLog(base);\n        intervalScaleProto.setExtent.call(this, start, end);\n    },\n\n    /**\n     * @return {number} end\n     */\n    getExtent: function () {\n        var base = this.base;\n        var extent = scaleProto.getExtent.call(this);\n        extent[0] = mathPow(base, extent[0]);\n        extent[1] = mathPow(base, extent[1]);\n\n        // Fix #4158\n        var originalScale = this._originalScale;\n        var originalExtent = originalScale.getExtent();\n        originalScale.__fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));\n        originalScale.__fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));\n\n        return extent;\n    },\n\n    /**\n     * @param  {Array.<number>} extent\n     */\n    unionExtent: function (extent) {\n        this._originalScale.unionExtent(extent);\n\n        var base = this.base;\n        extent[0] = mathLog(extent[0]) / mathLog(base);\n        extent[1] = mathLog(extent[1]) / mathLog(base);\n        scaleProto.unionExtent.call(this, extent);\n    },\n\n    /**\n     * @override\n     */\n    unionExtentFromData: function (data, dim) {\n        // TODO\n        // filter value that <= 0\n        this.unionExtent(data.getApproximateExtent(dim));\n    },\n\n    /**\n     * Update interval and extent of intervals for nice ticks\n     * @param  {number} [approxTickNum = 10] Given approx tick number\n     */\n    niceTicks: function (approxTickNum) {\n        approxTickNum = approxTickNum || 10;\n        var extent = this._extent;\n        var span = extent[1] - extent[0];\n        if (span === Infinity || span <= 0) {\n            return;\n        }\n\n        var interval = numberUtil.quantity(span);\n        var err = approxTickNum / span * interval;\n\n        // Filter ticks to get closer to the desired count.\n        if (err <= 0.5) {\n            interval *= 10;\n        }\n\n        // Interval should be integer\n        while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {\n            interval *= 10;\n        }\n\n        var niceExtent = [\n            numberUtil.round(mathCeil(extent[0] / interval) * interval),\n            numberUtil.round(mathFloor(extent[1] / interval) * interval)\n        ];\n\n        this._interval = interval;\n        this._niceExtent = niceExtent;\n    },\n\n    /**\n     * Nice extent.\n     * @override\n     */\n    niceExtent: function (opt) {\n        intervalScaleProto.niceExtent.call(this, opt);\n\n        var originalScale = this._originalScale;\n        originalScale.__fixMin = opt.fixMin;\n        originalScale.__fixMax = opt.fixMax;\n    }\n\n});\n\nzrUtil.each(['contain', 'normalize'], function (methodName) {\n    LogScale.prototype[methodName] = function (val) {\n        val = mathLog(val) / mathLog(this.base);\n        return scaleProto[methodName].call(this, val);\n    };\n});\n\nLogScale.create = function () {\n    return new LogScale();\n};\n\nfunction fixRoundingError(val, originalVal) {\n    return roundingErrorFix(val, getPrecisionSafe(originalVal));\n}\n\nexport default LogScale;"],"sourceRoot":""}