Merge remote-tracking branch 'upstream/main'

frontend/node_modules/zrender/lib/vml/Painter.d.ts

@@ -0,0 +1,2 @@
+declare function VMLPainter(root: any, storage: any): void;
+export default VMLPainter;

frontend/node_modules/zrender/lib/vml/Painter.js

@@ -0,0 +1,135 @@
+import { logError, each } from '../core/util.js';
+import * as vmlCore from './core.js';
+function parseInt10(val) {
+    return parseInt(val, 10);
+}
+function VMLPainter(root, storage) {
+    vmlCore.initVML();
+    this.root = root;
+    this.storage = storage;
+    var vmlViewport = document.createElement('div');
+    var vmlRoot = document.createElement('div');
+    vmlViewport.style.cssText = 'display:inline-block;overflow:hidden;position:relative;width:300px;height:150px;';
+    vmlRoot.style.cssText = 'position:absolute;left:0;top:0;';
+    root.appendChild(vmlViewport);
+    this._vmlRoot = vmlRoot;
+    this._vmlViewport = vmlViewport;
+    this.resize();
+    var oldDelFromStorage = storage.delFromStorage;
+    var oldAddToStorage = storage.addToStorage;
+    storage.delFromStorage = function (el) {
+        oldDelFromStorage.call(storage, el);
+        if (el) {
+            el.onRemove && el.onRemove(vmlRoot);
+        }
+    };
+    storage.addToStorage = function (el) {
+        el.onAdd && el.onAdd(vmlRoot);
+        oldAddToStorage.call(storage, el);
+    };
+    this._firstPaint = true;
+}
+VMLPainter.prototype = {
+    constructor: VMLPainter,
+    getType: function () {
+        return 'vml';
+    },
+    getViewportRoot: function () {
+        return this._vmlViewport;
+    },
+    getViewportRootOffset: function () {
+        var viewportRoot = this.getViewportRoot();
+        if (viewportRoot) {
+            return {
+                offsetLeft: viewportRoot.offsetLeft || 0,
+                offsetTop: viewportRoot.offsetTop || 0
+            };
+        }
+    },
+    refresh: function () {
+        var list = this.storage.getDisplayList(true, true);
+        this._paintList(list);
+    },
+    _paintList: function (list) {
+        var vmlRoot = this._vmlRoot;
+        for (var i = 0; i < list.length; i++) {
+            var el = list[i];
+            if (el.invisible || el.ignore) {
+                if (!el.__alreadyNotVisible) {
+                    el.onRemove(vmlRoot);
+                }
+                el.__alreadyNotVisible = true;
+            }
+            else {
+                if (el.__alreadyNotVisible) {
+                    el.onAdd(vmlRoot);
+                }
+                el.__alreadyNotVisible = false;
+                if (el.__dirty) {
+                    el.beforeBrush && el.beforeBrush();
+                    (el.brushVML || el.brush).call(el, vmlRoot);
+                    el.afterBrush && el.afterBrush();
+                }
+            }
+            el.__dirty = false;
+        }
+        if (this._firstPaint) {
+            this._vmlViewport.appendChild(vmlRoot);
+            this._firstPaint = false;
+        }
+    },
+    resize: function (width, height) {
+        var width = width == null ? this._getWidth() : width;
+        var height = height == null ? this._getHeight() : height;
+        if (this._width !== width || this._height !== height) {
+            this._width = width;
+            this._height = height;
+            var vmlViewportStyle = this._vmlViewport.style;
+            vmlViewportStyle.width = width + 'px';
+            vmlViewportStyle.height = height + 'px';
+        }
+    },
+    dispose: function () {
+        this.root.innerHTML = '';
+        this._vmlRoot =
+            this._vmlViewport =
+                this.storage = null;
+    },
+    getWidth: function () {
+        return this._width;
+    },
+    getHeight: function () {
+        return this._height;
+    },
+    clear: function () {
+        if (this._vmlViewport) {
+            this.root.removeChild(this._vmlViewport);
+        }
+    },
+    _getWidth: function () {
+        var root = this.root;
+        var stl = root.currentStyle;
+        return ((root.clientWidth || parseInt10(stl.width))
+            - parseInt10(stl.paddingLeft)
+            - parseInt10(stl.paddingRight)) | 0;
+    },
+    _getHeight: function () {
+        var root = this.root;
+        var stl = root.currentStyle;
+        return ((root.clientHeight || parseInt10(stl.height))
+            - parseInt10(stl.paddingTop)
+            - parseInt10(stl.paddingBottom)) | 0;
+    }
+};
+function createMethodNotSupport(method) {
+    return function () {
+        logError('In IE8.0 VML mode painter not support method "' + method + '"');
+    };
+}
+each([
+    'getLayer', 'insertLayer', 'eachLayer', 'eachBuiltinLayer', 'eachOtherLayer', 'getLayers',
+    'modLayer', 'delLayer', 'clearLayer', 'toDataURL', 'pathToImage'
+], function (name) {
+    VMLPainter.prototype[name] = createMethodNotSupport(name);
+});
+export default VMLPainter;

frontend/node_modules/zrender/lib/vml/Painter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Painter.js","sourceRoot":"","sources":["../../src/vml/Painter.ts"],"names":[],"mappings":";;AAKA,qCAAsC;AACtC,gCAAkC;AAClC,qCAAkC;AAElC,SAAS,UAAU,CAAC,GAAG;IACnB,OAAO,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AAC7B,CAAC;AAKD,SAAS,UAAU,CAAC,IAAI,EAAE,OAAO;IAE7B,OAAO,CAAC,OAAO,EAAE,CAAC;IAElB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAEjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAEvB,IAAI,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAEhD,IAAI,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAE5C,WAAW,CAAC,KAAK,CAAC,OAAO,GAAG,kFAAkF,CAAC;IAE/G,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,iCAAiC,CAAC;IAE1D,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAE9B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IACxB,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAEhC,IAAI,CAAC,MAAM,EAAE,CAAC;IAGd,IAAI,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC;IAC/C,IAAI,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC;IAC3C,OAAO,CAAC,cAAc,GAAG,UAAU,EAAE;QACjC,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAEpC,IAAI,EAAE,EAAE;YACJ,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;SACvC;IACL,CAAC,CAAC;IAEF,OAAO,CAAC,YAAY,GAAG,UAAU,EAAE;QAE/B,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAE9B,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACtC,CAAC,CAAC;IAEF,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;AAC5B,CAAC;AAED,UAAU,CAAC,SAAS,GAAG;IAEnB,WAAW,EAAE,UAAU;IAEvB,OAAO,EAAE;QACL,OAAO,KAAK,CAAC;IACjB,CAAC;IAKD,eAAe,EAAE;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,qBAAqB,EAAE;QACnB,IAAI,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAC1C,IAAI,YAAY,EAAE;YACd,OAAO;gBACH,UAAU,EAAE,YAAY,CAAC,UAAU,IAAI,CAAC;gBACxC,SAAS,EAAE,YAAY,CAAC,SAAS,IAAI,CAAC;aACzC,CAAC;SACL;IACL,CAAC;IAKD,OAAO,EAAE;QAEL,IAAI,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAEnD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,UAAU,EAAE,UAAU,IAAI;QACtB,IAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAClC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,IAAI,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC,MAAM,EAAE;gBAC3B,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE;oBACzB,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;iBACxB;gBAED,EAAE,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACjC;iBACI;gBACD,IAAI,EAAE,CAAC,mBAAmB,EAAE;oBACxB,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;iBACrB;gBACD,EAAE,CAAC,mBAAmB,GAAG,KAAK,CAAC;gBAC/B,IAAI,EAAE,CAAC,OAAO,EAAE;oBACZ,EAAE,CAAC,WAAW,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;oBACnC,CAAC,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;oBAC5C,EAAE,CAAC,UAAU,IAAI,EAAE,CAAC,UAAU,EAAE,CAAC;iBACpC;aACJ;YACD,EAAE,CAAC,OAAO,GAAG,KAAK,CAAC;SACtB;QAED,IAAI,IAAI,CAAC,WAAW,EAAE;YAKlB,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YACvC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;SAC5B;IACL,CAAC;IAED,MAAM,EAAE,UAAU,KAAK,EAAE,MAAM;QAC3B,IAAI,KAAK,GAAG,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACrD,IAAI,MAAM,GAAG,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;QAEzD,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM,EAAE;YAClD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;YAEtB,IAAI,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;YAC/C,gBAAgB,CAAC,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;YACtC,gBAAgB,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;SAC3C;IACL,CAAC;IAED,OAAO,EAAE;QACL,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;QAEzB,IAAI,CAAC,QAAQ;YACb,IAAI,CAAC,YAAY;gBACjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACxB,CAAC;IAED,QAAQ,EAAE;QACN,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,SAAS,EAAE;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,KAAK,EAAE;QACH,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC5C;IACL,CAAC;IAED,SAAS,EAAE;QACP,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACrB,IAAI,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAE5B,OAAO,CAAC,CAAC,IAAI,CAAC,WAAW,IAAI,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;cACzC,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC;cAC3B,UAAU,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAED,UAAU,EAAE;QACR,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACrB,IAAI,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAE5B,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;cAC3C,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC;cAC1B,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC;IACjD,CAAC;CACJ,CAAC;AAGF,SAAS,sBAAsB,CAAC,MAAM;IAClC,OAAO;QACH,eAAQ,CAAC,gDAAgD,GAAG,MAAM,GAAG,GAAG,CAAC,CAAC;IAC9E,CAAC,CAAC;AACN,CAAC;AAGD,WAAI,CAAC;IACD,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW;IACzF,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa;CACnE,EAAE,UAAU,IAAI;IACb,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;AAC9D,CAAC,CAAC,CAAC;AAEH,qBAAe,UAAU,CAAC"}

frontend/node_modules/zrender/lib/vml/core.d.ts

@@ -0,0 +1,3 @@
+export declare var doc: Document;
+export declare function createNode(tagName: any): any;
+export declare function initVML(): void;

frontend/node_modules/zrender/lib/vml/core.js

@@ -0,0 +1,35 @@
+import env from '../core/env.js';
+var urn = 'urn:schemas-microsoft-com:vml';
+var win = typeof window === 'undefined' ? null : window;
+var vmlInited = false;
+export var doc = win && win.document;
+export function createNode(tagName) {
+    return doCreateNode(tagName);
+}
+var doCreateNode;
+if (doc && !env.canvasSupported) {
+    try {
+        !doc.namespaces.zrvml && doc.namespaces.add('zrvml', urn);
+        doCreateNode = function (tagName) {
+            return doc.createElement('<zrvml:' + tagName + ' class="zrvml">');
+        };
+    }
+    catch (e) {
+        doCreateNode = function (tagName) {
+            return doc.createElement('<' + tagName + ' xmlns="' + urn + '" class="zrvml">');
+        };
+    }
+}
+export function initVML() {
+    if (vmlInited || !doc) {
+        return;
+    }
+    vmlInited = true;
+    var styleSheets = doc.styleSheets;
+    if (styleSheets.length < 31) {
+        doc.createStyleSheet().addRule('.zrvml', 'behavior:url(#default#VML)');
+    }
+    else {
+        styleSheets[0].addRule('.zrvml', 'behavior:url(#default#VML)');
+    }
+}

frontend/node_modules/zrender/lib/vml/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/vml/core.ts"],"names":[],"mappings":";;AACA,mCAA8B;AAG9B,IAAI,GAAG,GAAG,+BAA+B,CAAC;AAC1C,IAAI,GAAG,GAAG,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC;AAExD,IAAI,SAAS,GAAG,KAAK,CAAC;AAEX,QAAA,GAAG,GAAG,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC;AAErC,SAAgB,UAAU,CAAC,OAAO;IAC9B,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC;AACjC,CAAC;AAFD,gCAEC;AAGD,IAAI,YAAY,CAAC;AAEjB,IAAI,WAAG,IAAI,CAAC,gBAAG,CAAC,eAAe,EAAE;IAC7B,IAAI;QACA,CAAC,WAAG,CAAC,UAAU,CAAC,KAAK,IAAI,WAAG,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC1D,YAAY,GAAG,UAAU,OAAO;YAC5B,OAAO,WAAG,CAAC,aAAa,CAAC,SAAS,GAAG,OAAO,GAAG,iBAAiB,CAAC,CAAC;QACtE,CAAC,CAAC;KACL;IACD,OAAO,CAAC,EAAE;QACN,YAAY,GAAG,UAAU,OAAO;YAC5B,OAAO,WAAG,CAAC,aAAa,CAAC,GAAG,GAAG,OAAO,GAAG,UAAU,GAAG,GAAG,GAAG,kBAAkB,CAAC,CAAC;QACpF,CAAC,CAAC;KACL;CACJ;AAGD,SAAgB,OAAO;IACnB,IAAI,SAAS,IAAI,CAAC,WAAG,EAAE;QACnB,OAAO;KACV;IACD,SAAS,GAAG,IAAI,CAAC;IAEjB,IAAI,WAAW,GAAG,WAAG,CAAC,WAAW,CAAC;IAClC,IAAI,WAAW,CAAC,MAAM,GAAG,EAAE,EAAE;QACzB,WAAG,CAAC,gBAAgB,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAC;KAC1E;SACI;QAED,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAC;KAClE;AACL,CAAC;AAdD,0BAcC"}

frontend/node_modules/zrender/lib/vml/graphic.d.ts

@@ -0,0 +1 @@
+export {};

frontend/node_modules/zrender/lib/vml/graphic.js

@@ -0,0 +1,758 @@
+import env from '../core/env.js';
+import { applyTransform } from '../core/vector.js';
+import BoundingRect from '../core/BoundingRect.js';
+import * as colorTool from '../tool/color.js';
+import * as textContain from '../graphic/text/parse.js';
+import Displayable from '../graphic/Displayable.js';
+import ZRImage from '../graphic/Image.js';
+import Text from '../graphic/TSpan.js';
+import Path from '../graphic/Path.js';
+import PathProxy from '../core/PathProxy.js';
+import Gradient from '../graphic/Gradient.js';
+import * as vmlCore from './core.js';
+var CMD = PathProxy.CMD;
+var round = Math.round;
+var sqrt = Math.sqrt;
+var abs = Math.abs;
+var cos = Math.cos;
+var sin = Math.sin;
+var mathMax = Math.max;
+if (!env.canvasSupported) {
+    var comma = ',';
+    var imageTransformPrefix = 'progid:DXImageTransform.Microsoft';
+    var Z = 21600;
+    var Z2 = Z / 2;
+    var ZLEVEL_BASE = 100000;
+    var Z_BASE = 1000;
+    var initRootElStyle = function (el) {
+        el.style.cssText = 'position:absolute;left:0;top:0;width:1px;height:1px;';
+        el.coordsize = Z + ',' + Z;
+        el.coordorigin = '0,0';
+    };
+    var encodeHtmlAttribute = function (s) {
+        return String(s).replace(/&/g, '&').replace(/"/g, '"');
+    };
+    var rgb2Str = function (r, g, b) {
+        return 'rgb(' + [r, g, b].join(',') + ')';
+    };
+    var append = function (parent, child) {
+        if (child && parent && child.parentNode !== parent) {
+            parent.appendChild(child);
+        }
+    };
+    var remove = function (parent, child) {
+        if (child && parent && child.parentNode === parent) {
+            parent.removeChild(child);
+        }
+    };
+    var getZIndex = function (zlevel, z, z2) {
+        return (parseFloat(zlevel) || 0) * ZLEVEL_BASE + (parseFloat(z) || 0) * Z_BASE + z2;
+    };
+    var parsePercent = textHelper.parsePercent;
+    var setColorAndOpacity = function (el, color, opacity) {
+        var colorArr = colorTool.parse(color);
+        opacity = +opacity;
+        if (isNaN(opacity)) {
+            opacity = 1;
+        }
+        if (colorArr) {
+            el.color = rgb2Str(colorArr[0], colorArr[1], colorArr[2]);
+            el.opacity = opacity * colorArr[3];
+        }
+    };
+    var getColorAndAlpha = function (color) {
+        var colorArr = colorTool.parse(color);
+        return [
+            rgb2Str(colorArr[0], colorArr[1], colorArr[2]),
+            colorArr[3]
+        ];
+    };
+    var updateFillNode = function (el, style, zrEl) {
+        var fill = style.fill;
+        if (fill != null) {
+            if (fill instanceof Gradient) {
+                var gradientType;
+                var angle = 0;
+                var focus = [0, 0];
+                var shift = 0;
+                var expansion = 1;
+                var rect = zrEl.getBoundingRect();
+                var rectWidth = rect.width;
+                var rectHeight = rect.height;
+                if (fill.type === 'linear') {
+                    gradientType = 'gradient';
+                    var transform = zrEl.transform;
+                    var p0 = [fill.x * rectWidth, fill.y * rectHeight];
+                    var p1 = [fill.x2 * rectWidth, fill.y2 * rectHeight];
+                    if (transform) {
+                        applyTransform(p0, p0, transform);
+                        applyTransform(p1, p1, transform);
+                    }
+                    var dx = p1[0] - p0[0];
+                    var dy = p1[1] - p0[1];
+                    angle = Math.atan2(dx, dy) * 180 / Math.PI;
+                    if (angle < 0) {
+                        angle += 360;
+                    }
+                    if (angle < 1e-6) {
+                        angle = 0;
+                    }
+                }
+                else {
+                    gradientType = 'gradientradial';
+                    var p0 = [fill.x * rectWidth, fill.y * rectHeight];
+                    var transform = zrEl.transform;
+                    var scale = zrEl.scale;
+                    var width = rectWidth;
+                    var height = rectHeight;
+                    focus = [
+                        (p0[0] - rect.x) / width,
+                        (p0[1] - rect.y) / height
+                    ];
+                    if (transform) {
+                        applyTransform(p0, p0, transform);
+                    }
+                    width /= scale[0] * Z;
+                    height /= scale[1] * Z;
+                    var dimension = mathMax(width, height);
+                    shift = 2 * 0 / dimension;
+                    expansion = 2 * fill.r / dimension - shift;
+                }
+                var stops = fill.colorStops.slice();
+                stops.sort(function (cs1, cs2) {
+                    return cs1.offset - cs2.offset;
+                });
+                var length = stops.length;
+                var colorAndAlphaList = [];
+                var colors = [];
+                for (var i = 0; i < length; i++) {
+                    var stop = stops[i];
+                    var colorAndAlpha = getColorAndAlpha(stop.color);
+                    colors.push(stop.offset * expansion + shift + ' ' + colorAndAlpha[0]);
+                    if (i === 0 || i === length - 1) {
+                        colorAndAlphaList.push(colorAndAlpha);
+                    }
+                }
+                if (length >= 2) {
+                    var color1 = colorAndAlphaList[0][0];
+                    var color2 = colorAndAlphaList[1][0];
+                    var opacity1 = colorAndAlphaList[0][1] * style.opacity;
+                    var opacity2 = colorAndAlphaList[1][1] * style.opacity;
+                    el.type = gradientType;
+                    el.method = 'none';
+                    el.focus = '100%';
+                    el.angle = angle;
+                    el.color = color1;
+                    el.color2 = color2;
+                    el.colors = colors.join(',');
+                    el.opacity = opacity2;
+                    el.opacity2 = opacity1;
+                }
+                if (gradientType === 'radial') {
+                    el.focusposition = focus.join(',');
+                }
+            }
+            else {
+                setColorAndOpacity(el, fill, style.opacity);
+            }
+        }
+    };
+    var updateStrokeNode = function (el, style) {
+        if (style.lineDash) {
+            el.dashstyle = style.lineDash.join(' ');
+        }
+        if (style.stroke != null && !(style.stroke instanceof Gradient)) {
+            setColorAndOpacity(el, style.stroke, style.opacity);
+        }
+    };
+    var updateFillAndStroke = function (vmlEl, type, style, zrEl) {
+        var isFill = type === 'fill';
+        var el = vmlEl.getElementsByTagName(type)[0];
+        if (style[type] != null && style[type] !== 'none' && (isFill || (!isFill && style.lineWidth))) {
+            vmlEl[isFill ? 'filled' : 'stroked'] = 'true';
+            if (style[type] instanceof Gradient) {
+                remove(vmlEl, el);
+            }
+            if (!el) {
+                el = vmlCore.createNode(type);
+            }
+            isFill ? updateFillNode(el, style, zrEl) : updateStrokeNode(el, style);
+            append(vmlEl, el);
+        }
+        else {
+            vmlEl[isFill ? 'filled' : 'stroked'] = 'false';
+            remove(vmlEl, el);
+        }
+    };
+    var points = [[], [], []];
+    var pathDataToString = function (path, m) {
+        var M = CMD.M;
+        var C = CMD.C;
+        var L = CMD.L;
+        var A = CMD.A;
+        var Q = CMD.Q;
+        var str = [];
+        var nPoint;
+        var cmdStr;
+        var cmd;
+        var i;
+        var xi;
+        var yi;
+        var data = path.data;
+        var dataLength = path.len();
+        for (i = 0; i < dataLength;) {
+            cmd = data[i++];
+            cmdStr = '';
+            nPoint = 0;
+            switch (cmd) {
+                case M:
+                    cmdStr = ' m ';
+                    nPoint = 1;
+                    xi = data[i++];
+                    yi = data[i++];
+                    points[0][0] = xi;
+                    points[0][1] = yi;
+                    break;
+                case L:
+                    cmdStr = ' l ';
+                    nPoint = 1;
+                    xi = data[i++];
+                    yi = data[i++];
+                    points[0][0] = xi;
+                    points[0][1] = yi;
+                    break;
+                case Q:
+                case C:
+                    cmdStr = ' c ';
+                    nPoint = 3;
+                    var x1 = data[i++];
+                    var y1 = data[i++];
+                    var x2 = data[i++];
+                    var y2 = data[i++];
+                    var x3;
+                    var y3;
+                    if (cmd === Q) {
+                        x3 = x2;
+                        y3 = y2;
+                        x2 = (x2 + 2 * x1) / 3;
+                        y2 = (y2 + 2 * y1) / 3;
+                        x1 = (xi + 2 * x1) / 3;
+                        y1 = (yi + 2 * y1) / 3;
+                    }
+                    else {
+                        x3 = data[i++];
+                        y3 = data[i++];
+                    }
+                    points[0][0] = x1;
+                    points[0][1] = y1;
+                    points[1][0] = x2;
+                    points[1][1] = y2;
+                    points[2][0] = x3;
+                    points[2][1] = y3;
+                    xi = x3;
+                    yi = y3;
+                    break;
+                case A:
+                    var x = 0;
+                    var y = 0;
+                    var sx = 1;
+                    var sy = 1;
+                    var angle = 0;
+                    if (m) {
+                        x = m[4];
+                        y = m[5];
+                        sx = sqrt(m[0] * m[0] + m[1] * m[1]);
+                        sy = sqrt(m[2] * m[2] + m[3] * m[3]);
+                        angle = Math.atan2(-m[1] / sy, m[0] / sx);
+                    }
+                    var cx = data[i++];
+                    var cy = data[i++];
+                    var rx = data[i++];
+                    var ry = data[i++];
+                    var startAngle = data[i++] + angle;
+                    var endAngle = data[i++] + startAngle + angle;
+                    i++;
+                    var clockwise = data[i++];
+                    var x0 = cx + cos(startAngle) * rx;
+                    var y0 = cy + sin(startAngle) * ry;
+                    var x1 = cx + cos(endAngle) * rx;
+                    var y1 = cy + sin(endAngle) * ry;
+                    var type = clockwise ? ' wa ' : ' at ';
+                    if (Math.abs(x0 - x1) < 1e-4) {
+                        if (Math.abs(endAngle - startAngle) > 1e-2) {
+                            if (clockwise) {
+                                x0 += 270 / Z;
+                            }
+                        }
+                        else {
+                            if (Math.abs(y0 - cy) < 1e-4) {
+                                if ((clockwise && x0 < cx) || (!clockwise && x0 > cx)) {
+                                    y1 -= 270 / Z;
+                                }
+                                else {
+                                    y1 += 270 / Z;
+                                }
+                            }
+                            else if ((clockwise && y0 < cy) || (!clockwise && y0 > cy)) {
+                                x1 += 270 / Z;
+                            }
+                            else {
+                                x1 -= 270 / Z;
+                            }
+                        }
+                    }
+                    str.push(type, round(((cx - rx) * sx + x) * Z - Z2), comma, round(((cy - ry) * sy + y) * Z - Z2), comma, round(((cx + rx) * sx + x) * Z - Z2), comma, round(((cy + ry) * sy + y) * Z - Z2), comma, round((x0 * sx + x) * Z - Z2), comma, round((y0 * sy + y) * Z - Z2), comma, round((x1 * sx + x) * Z - Z2), comma, round((y1 * sy + y) * Z - Z2));
+                    xi = x1;
+                    yi = y1;
+                    break;
+                case CMD.R:
+                    var p0 = points[0];
+                    var p1 = points[1];
+                    p0[0] = data[i++];
+                    p0[1] = data[i++];
+                    p1[0] = p0[0] + data[i++];
+                    p1[1] = p0[1] + data[i++];
+                    if (m) {
+                        applyTransform(p0, p0, m);
+                        applyTransform(p1, p1, m);
+                    }
+                    p0[0] = round(p0[0] * Z - Z2);
+                    p1[0] = round(p1[0] * Z - Z2);
+                    p0[1] = round(p0[1] * Z - Z2);
+                    p1[1] = round(p1[1] * Z - Z2);
+                    str.push(' m ', p0[0], comma, p0[1], ' l ', p1[0], comma, p0[1], ' l ', p1[0], comma, p1[1], ' l ', p0[0], comma, p1[1]);
+                    break;
+                case CMD.Z:
+                    str.push(' x ');
+            }
+            if (nPoint > 0) {
+                str.push(cmdStr);
+                for (var k = 0; k < nPoint; k++) {
+                    var p = points[k];
+                    m && applyTransform(p, p, m);
+                    str.push(round(p[0] * Z - Z2), comma, round(p[1] * Z - Z2), k < nPoint - 1 ? comma : '');
+                }
+            }
+        }
+        return str.join('');
+    };
+    Path.prototype.brushVML = function (vmlRoot) {
+        var style = this.style;
+        var vmlEl = this._vmlEl;
+        if (!vmlEl) {
+            vmlEl = vmlCore.createNode('shape');
+            initRootElStyle(vmlEl);
+            this._vmlEl = vmlEl;
+        }
+        updateFillAndStroke(vmlEl, 'fill', style, this);
+        updateFillAndStroke(vmlEl, 'stroke', style, this);
+        var m = this.transform;
+        var needTransform = m != null;
+        var strokeEl = vmlEl.getElementsByTagName('stroke')[0];
+        if (strokeEl) {
+            var lineWidth = style.lineWidth;
+            if (needTransform && !style.strokeNoScale) {
+                var det = m[0] * m[3] - m[1] * m[2];
+                lineWidth *= sqrt(abs(det));
+            }
+            strokeEl.weight = lineWidth + 'px';
+        }
+        var path = this.path || (this.path = new PathProxy());
+        if (this.__dirtyPath) {
+            path.beginPath();
+            path.subPixelOptimize = false;
+            this.buildPath(path, this.shape);
+            path.toStatic();
+            this.__dirtyPath = false;
+        }
+        vmlEl.path = pathDataToString(path, this.transform);
+        vmlEl.style.zIndex = getZIndex(this.zlevel, this.z, this.z2);
+        append(vmlRoot, vmlEl);
+        if (style.text != null) {
+            this.drawRectText(vmlRoot, this.getBoundingRect());
+        }
+        else {
+            this.removeRectText(vmlRoot);
+        }
+    };
+    Path.prototype.onRemove = function (vmlRoot) {
+        remove(vmlRoot, this._vmlEl);
+        this.removeRectText(vmlRoot);
+    };
+    Path.prototype.onAdd = function (vmlRoot) {
+        append(vmlRoot, this._vmlEl);
+        this.appendRectText(vmlRoot);
+    };
+    var isImage = function (img) {
+        return (typeof img === 'object') && img.tagName && img.tagName.toUpperCase() === 'IMG';
+    };
+    ZRImage.prototype.brushVML = function (vmlRoot) {
+        var style = this.style;
+        var image = style.image;
+        var ow;
+        var oh;
+        if (isImage(image)) {
+            var src = image.src;
+            if (src === this._imageSrc) {
+                ow = this._imageWidth;
+                oh = this._imageHeight;
+            }
+            else {
+                var imageRuntimeStyle = image.runtimeStyle;
+                var oldRuntimeWidth = imageRuntimeStyle.width;
+                var oldRuntimeHeight = imageRuntimeStyle.height;
+                imageRuntimeStyle.width = 'auto';
+                imageRuntimeStyle.height = 'auto';
+                ow = image.width;
+                oh = image.height;
+                imageRuntimeStyle.width = oldRuntimeWidth;
+                imageRuntimeStyle.height = oldRuntimeHeight;
+                this._imageSrc = src;
+                this._imageWidth = ow;
+                this._imageHeight = oh;
+            }
+            image = src;
+        }
+        else {
+            if (image === this._imageSrc) {
+                ow = this._imageWidth;
+                oh = this._imageHeight;
+            }
+        }
+        if (!image) {
+            return;
+        }
+        var x = style.x || 0;
+        var y = style.y || 0;
+        var dw = style.width;
+        var dh = style.height;
+        var sw = style.sWidth;
+        var sh = style.sHeight;
+        var sx = style.sx || 0;
+        var sy = style.sy || 0;
+        var hasCrop = sw && sh;
+        var vmlEl = this._vmlEl;
+        if (!vmlEl) {
+            vmlEl = vmlCore.doc.createElement('div');
+            initRootElStyle(vmlEl);
+            this._vmlEl = vmlEl;
+        }
+        var vmlElStyle = vmlEl.style;
+        var hasRotation = false;
+        var m;
+        var scaleX = 1;
+        var scaleY = 1;
+        if (this.transform) {
+            m = this.transform;
+            scaleX = sqrt(m[0] * m[0] + m[1] * m[1]);
+            scaleY = sqrt(m[2] * m[2] + m[3] * m[3]);
+            hasRotation = m[1] || m[2];
+        }
+        if (hasRotation) {
+            var p0 = [x, y];
+            var p1 = [x + dw, y];
+            var p2 = [x, y + dh];
+            var p3 = [x + dw, y + dh];
+            applyTransform(p0, p0, m);
+            applyTransform(p1, p1, m);
+            applyTransform(p2, p2, m);
+            applyTransform(p3, p3, m);
+            var maxX = mathMax(p0[0], p1[0], p2[0], p3[0]);
+            var maxY = mathMax(p0[1], p1[1], p2[1], p3[1]);
+            var transformFilter = [];
+            transformFilter.push('M11=', m[0] / scaleX, comma, 'M12=', m[2] / scaleY, comma, 'M21=', m[1] / scaleX, comma, 'M22=', m[3] / scaleY, comma, 'Dx=', round(x * scaleX + m[4]), comma, 'Dy=', round(y * scaleY + m[5]));
+            vmlElStyle.padding = '0 ' + round(maxX) + 'px ' + round(maxY) + 'px 0';
+            vmlElStyle.filter = imageTransformPrefix + '.Matrix('
+                + transformFilter.join('') + ', SizingMethod=clip)';
+        }
+        else {
+            if (m) {
+                x = x * scaleX + m[4];
+                y = y * scaleY + m[5];
+            }
+            vmlElStyle.filter = '';
+            vmlElStyle.left = round(x) + 'px';
+            vmlElStyle.top = round(y) + 'px';
+        }
+        var imageEl = this._imageEl;
+        var cropEl = this._cropEl;
+        if (!imageEl) {
+            imageEl = vmlCore.doc.createElement('div');
+            this._imageEl = imageEl;
+        }
+        var imageELStyle = imageEl.style;
+        if (hasCrop) {
+            if (!(ow && oh)) {
+                var tmpImage = new Image();
+                var self = this;
+                tmpImage.onload = function () {
+                    tmpImage.onload = null;
+                    ow = tmpImage.width;
+                    oh = tmpImage.height;
+                    imageELStyle.width = round(scaleX * ow * dw / sw) + 'px';
+                    imageELStyle.height = round(scaleY * oh * dh / sh) + 'px';
+                    self._imageWidth = ow;
+                    self._imageHeight = oh;
+                    self._imageSrc = image;
+                };
+                tmpImage.src = image;
+            }
+            else {
+                imageELStyle.width = round(scaleX * ow * dw / sw) + 'px';
+                imageELStyle.height = round(scaleY * oh * dh / sh) + 'px';
+            }
+            if (!cropEl) {
+                cropEl = vmlCore.doc.createElement('div');
+                cropEl.style.overflow = 'hidden';
+                this._cropEl = cropEl;
+            }
+            var cropElStyle = cropEl.style;
+            cropElStyle.width = round((dw + sx * dw / sw) * scaleX);
+            cropElStyle.height = round((dh + sy * dh / sh) * scaleY);
+            cropElStyle.filter = imageTransformPrefix + '.Matrix(Dx='
+                + (-sx * dw / sw * scaleX) + ',Dy=' + (-sy * dh / sh * scaleY) + ')';
+            if (!cropEl.parentNode) {
+                vmlEl.appendChild(cropEl);
+            }
+            if (imageEl.parentNode !== cropEl) {
+                cropEl.appendChild(imageEl);
+            }
+        }
+        else {
+            imageELStyle.width = round(scaleX * dw) + 'px';
+            imageELStyle.height = round(scaleY * dh) + 'px';
+            vmlEl.appendChild(imageEl);
+            if (cropEl && cropEl.parentNode) {
+                vmlEl.removeChild(cropEl);
+                this._cropEl = null;
+            }
+        }
+        var filterStr = '';
+        var alpha = style.opacity;
+        if (alpha < 1) {
+            filterStr += '.Alpha(opacity=' + round(alpha * 100) + ') ';
+        }
+        filterStr += imageTransformPrefix + '.AlphaImageLoader(src=' + image + ', SizingMethod=scale)';
+        imageELStyle.filter = filterStr;
+        vmlEl.style.zIndex = getZIndex(this.zlevel, this.z, this.z2);
+        append(vmlRoot, vmlEl);
+        if (style.text != null) {
+            this.drawRectText(vmlRoot, this.getBoundingRect());
+        }
+    };
+    ZRImage.prototype.onRemove = function (vmlRoot) {
+        remove(vmlRoot, this._vmlEl);
+        this._vmlEl = null;
+        this._cropEl = null;
+        this._imageEl = null;
+        this.removeRectText(vmlRoot);
+    };
+    ZRImage.prototype.onAdd = function (vmlRoot) {
+        append(vmlRoot, this._vmlEl);
+        this.appendRectText(vmlRoot);
+    };
+    var DEFAULT_STYLE_NORMAL = 'normal';
+    var fontStyleCache = {};
+    var fontStyleCacheCount = 0;
+    var MAX_FONT_CACHE_SIZE = 100;
+    var fontEl = document.createElement('div');
+    var getFontStyle = function (fontString) {
+        var fontStyle = fontStyleCache[fontString];
+        if (!fontStyle) {
+            if (fontStyleCacheCount > MAX_FONT_CACHE_SIZE) {
+                fontStyleCacheCount = 0;
+                fontStyleCache = {};
+            }
+            var style = fontEl.style;
+            var fontFamily;
+            try {
+                style.font = fontString;
+                fontFamily = style.fontFamily.split(',')[0];
+            }
+            catch (e) {
+            }
+            fontStyle = {
+                style: style.fontStyle || DEFAULT_STYLE_NORMAL,
+                variant: style.fontVariant || DEFAULT_STYLE_NORMAL,
+                weight: style.fontWeight || DEFAULT_STYLE_NORMAL,
+                size: parseFloat(style.fontSize || 12) | 0,
+                family: fontFamily || 'Microsoft YaHei'
+            };
+            fontStyleCache[fontString] = fontStyle;
+            fontStyleCacheCount++;
+        }
+        return fontStyle;
+    };
+    var textMeasureEl;
+    textContain.$override('measureText', function (text, textFont) {
+        var doc = vmlCore.doc;
+        if (!textMeasureEl) {
+            textMeasureEl = doc.createElement('div');
+            textMeasureEl.style.cssText = 'position:absolute;top:-20000px;left:0;'
+                + 'padding:0;margin:0;border:none;white-space:pre;';
+            vmlCore.doc.body.appendChild(textMeasureEl);
+        }
+        try {
+            textMeasureEl.style.font = textFont;
+        }
+        catch (ex) {
+        }
+        textMeasureEl.innerHTML = '';
+        textMeasureEl.appendChild(doc.createTextNode(text));
+        return {
+            width: textMeasureEl.offsetWidth
+        };
+    });
+    var tmpRect = new BoundingRect(0, 0, 0, 0);
+    var drawRectText = function (vmlRoot, rect, textRect, fromTextEl) {
+        var style = this.style;
+        this.__dirty && textHelper.normalizeTextStyle(style, true);
+        var text = style.text;
+        text != null && (text += '');
+        if (!text) {
+            return;
+        }
+        if (style.rich) {
+            var contentBlock = textContain.parseRichText(text, style);
+            text = [];
+            for (var i = 0; i < contentBlock.lines.length; i++) {
+                var tokens = contentBlock.lines[i].tokens;
+                var textLine = [];
+                for (var j = 0; j < tokens.length; j++) {
+                    textLine.push(tokens[j].text);
+                }
+                text.push(textLine.join(''));
+            }
+            text = text.join('\n');
+        }
+        var x;
+        var y;
+        var align = style.textAlign;
+        var verticalAlign = style.textVerticalAlign;
+        var fontStyle = getFontStyle(style.font);
+        var font = fontStyle.style + ' ' + fontStyle.variant + ' ' + fontStyle.weight + ' '
+            + fontStyle.size + 'px "' + fontStyle.family + '"';
+        textRect = textRect || textContain.getBoundingRect(text, font, align, verticalAlign, style.textPadding, style.textLineHeight);
+        var m = this.transform;
+        if (m && !fromTextEl) {
+            tmpRect.copy(rect);
+            tmpRect.applyTransform(m);
+            rect = tmpRect;
+        }
+        if (!fromTextEl) {
+            var textPosition = style.textPosition;
+            if (textPosition instanceof Array) {
+                x = rect.x + parsePercent(textPosition[0], rect.width);
+                y = rect.y + parsePercent(textPosition[1], rect.height);
+                align = align || 'left';
+            }
+            else {
+                var res = this.calculateTextPosition
+                    ? this.calculateTextPosition({}, style, rect)
+                    : textContain.calculateTextPosition({}, style, rect);
+                x = res.x;
+                y = res.y;
+                align = align || res.align;
+                verticalAlign = verticalAlign || res.verticalAlign;
+            }
+        }
+        else {
+            x = rect.x;
+            y = rect.y;
+        }
+        x = textContain.adjustTextX(x, textRect.width, align);
+        y = textContain.adjustTextY(y, textRect.height, verticalAlign);
+        y += textRect.height / 2;
+        var createNode = vmlCore.createNode;
+        var textVmlEl = this._textVmlEl;
+        var pathEl;
+        var textPathEl;
+        var skewEl;
+        if (!textVmlEl) {
+            textVmlEl = createNode('line');
+            pathEl = createNode('path');
+            textPathEl = createNode('textpath');
+            skewEl = createNode('skew');
+            textPathEl.style['v-text-align'] = 'left';
+            initRootElStyle(textVmlEl);
+            pathEl.textpathok = true;
+            textPathEl.on = true;
+            textVmlEl.from = '0 0';
+            textVmlEl.to = '1000 0.05';
+            append(textVmlEl, skewEl);
+            append(textVmlEl, pathEl);
+            append(textVmlEl, textPathEl);
+            this._textVmlEl = textVmlEl;
+        }
+        else {
+            skewEl = textVmlEl.firstChild;
+            pathEl = skewEl.nextSibling;
+            textPathEl = pathEl.nextSibling;
+        }
+        var coords = [x, y];
+        var textVmlElStyle = textVmlEl.style;
+        if (m && fromTextEl) {
+            applyTransform(coords, coords, m);
+            skewEl.on = true;
+            skewEl.matrix = m[0].toFixed(3) + comma + m[2].toFixed(3) + comma
+                + m[1].toFixed(3) + comma + m[3].toFixed(3) + ',0,0';
+            skewEl.offset = (round(coords[0]) || 0) + ',' + (round(coords[1]) || 0);
+            skewEl.origin = '0 0';
+            textVmlElStyle.left = '0px';
+            textVmlElStyle.top = '0px';
+        }
+        else {
+            skewEl.on = false;
+            textVmlElStyle.left = round(x) + 'px';
+            textVmlElStyle.top = round(y) + 'px';
+        }
+        textPathEl.string = encodeHtmlAttribute(text);
+        try {
+            textPathEl.style.font = font;
+        }
+        catch (e) { }
+        updateFillAndStroke(textVmlEl, 'fill', {
+            fill: style.textFill,
+            opacity: style.opacity
+        }, this);
+        updateFillAndStroke(textVmlEl, 'stroke', {
+            stroke: style.textStroke,
+            opacity: style.opacity,
+            lineDash: style.lineDash || null
+        }, this);
+        textVmlEl.style.zIndex = getZIndex(this.zlevel, this.z, this.z2);
+        append(vmlRoot, textVmlEl);
+    };
+    var removeRectText = function (vmlRoot) {
+        remove(vmlRoot, this._textVmlEl);
+        this._textVmlEl = null;
+    };
+    var appendRectText = function (vmlRoot) {
+        append(vmlRoot, this._textVmlEl);
+    };
+    var list = [RectText, Displayable, ZRImage, Path, Text];
+    for (var i = 0; i < list.length; i++) {
+        var proto = list[i].prototype;
+        proto.drawRectText = drawRectText;
+        proto.removeRectText = removeRectText;
+        proto.appendRectText = appendRectText;
+    }
+    Text.prototype.brushVML = function (vmlRoot) {
+        var style = this.style;
+        if (style.text != null) {
+            this.drawRectText(vmlRoot, {
+                x: style.x || 0, y: style.y || 0,
+                width: 0, height: 0
+            }, this.getBoundingRect(), true);
+        }
+        else {
+            this.removeRectText(vmlRoot);
+        }
+    };
+    Text.prototype.onRemove = function (vmlRoot) {
+        this.removeRectText(vmlRoot);
+    };
+    Text.prototype.onAdd = function (vmlRoot) {
+        this.appendRectText(vmlRoot);
+    };
+}

frontend/node_modules/zrender/lib/vml/vml.d.ts

@@ -0,0 +1 @@
+import './graphic';

frontend/node_modules/zrender/lib/vml/vml.js

@@ -0,0 +1,4 @@
+import './graphic.js';
+import { registerPainter } from '../zrender.js';
+import Painter from './Painter.js';
+registerPainter('vml', Painter);

frontend/node_modules/zrender/lib/vml/vml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vml.js","sourceRoot":"","sources":["../../src/vml/vml.ts"],"names":[],"mappings":";;AAEA,qBAAmB;AACnB,sCAA2C;AAC3C,qCAAgC;AAEhC,yBAAe,CAAC,KAAK,EAAE,oBAAO,CAAC,CAAC"}