@visactor/vrender 0.14.2 → 0.15.0-alpha.0

package/dist/index.js

@@ -10,6 +10,33 @@
 		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 	}
 
+	function _iterableToArrayLimit(arr, i) {
+	  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+	  if (null != _i) {
+	    var _s,
+	      _e,
+	      _x,
+	      _r,
+	      _arr = [],
+	      _n = !0,
+	      _d = !1;
+	    try {
+	      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+	        if (Object(_i) !== _i) return;
+	        _n = !1;
+	      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+	    } catch (err) {
+	      _d = !0, _e = err;
+	    } finally {
+	      try {
+	        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+	      } finally {
+	        if (_d) throw _e;
+	      }
+	    }
+	    return _arr;
+	  }
+	}
 	function _typeof(obj) {
 	  "@babel/helpers - typeof";
 
@@ -41,6 +68,20 @@
 	  });
 	  return Constructor;
 	}
+	function _defineProperty(obj, key, value) {
+	  key = _toPropertyKey(key);
+	  if (key in obj) {
+	    Object.defineProperty(obj, key, {
+	      value: value,
+	      enumerable: true,
+	      configurable: true,
+	      writable: true
+	    });
+	  } else {
+	    obj[key] = value;
+	  }
+	  return obj;
+	}
 	function _inherits(subClass, superClass) {
 	  if (typeof superClass !== "function" && superClass !== null) {
 	    throw new TypeError("Super expression must either be null or a function");
@@ -109,6 +150,28 @@
 	    return _possibleConstructorReturn(this, result);
 	  };
 	}
+	function _slicedToArray(arr, i) {
+	  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+	}
+	function _arrayWithHoles(arr) {
+	  if (Array.isArray(arr)) return arr;
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+	  if (!o) return;
+	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+	  var n = Object.prototype.toString.call(o).slice(8, -1);
+	  if (n === "Object" && o.constructor) n = o.constructor.name;
+	  if (n === "Map" || n === "Set") return Array.from(o);
+	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+	  if (len == null || len > arr.length) len = arr.length;
+	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	  return arr2;
+	}
+	function _nonIterableRest() {
+	  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
 	function _toPrimitive(input, hint) {
 	  if (typeof input !== "object" || input === null) return input;
 	  var prim = input[Symbol.toPrimitive];
@@ -3649,7 +3712,7 @@
 	  return Array.isArray(object) && object.some(isPromise);
 	}
 
-	var __awaiter$4 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
+	var __awaiter$3 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
 	  function adopt(value) {
 	    return value instanceof P ? value : new P(function (resolve) {
 	      resolve(value);
@@ -3794,7 +3857,7 @@
 	  }
 	};
 	var _saveAsyncResultToSingletonScope = function _saveAsyncResultToSingletonScope(binding, asyncResult) {
-	  return __awaiter$4(void 0, void 0, void 0, function () {
+	  return __awaiter$3(void 0, void 0, void 0, function () {
 	    var result, ex_1;
 	    return __generator$3(this, function (_a) {
 	      switch (_a.label) {
@@ -3882,7 +3945,7 @@
 	  };
 	  return __assign$1.apply(this, arguments);
 	};
-	var __awaiter$3 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
+	var __awaiter$2 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
 	  function adopt(value) {
 	    return value instanceof P ? value : new P(function (resolve) {
 	      resolve(value);
@@ -4055,7 +4118,7 @@
 	  return instance;
 	}
 	function createInstanceWithInjectionsAsync(args) {
-	  return __awaiter$3(this, void 0, void 0, function () {
+	  return __awaiter$2(this, void 0, void 0, function () {
 	    var constructorInjections, propertyInjections;
 	    return __generator$2(this, function (_a) {
 	      switch (_a.label) {
@@ -4075,7 +4138,7 @@
 	  });
 	}
 	function possiblyWaitInjections(possiblePromiseinjections) {
-	  return __awaiter$3(this, void 0, void 0, function () {
+	  return __awaiter$2(this, void 0, void 0, function () {
 	    var injections, _i, possiblePromiseinjections_1, injection;
 	    return __generator$2(this, function (_a) {
 	      injections = [];
@@ -4138,7 +4201,7 @@
 	  }
 	}
 
-	var __awaiter$2 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
+	var __awaiter$1 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
 	  function adopt(value) {
 	    return value instanceof P ? value : new P(function (resolve) {
 	      resolve(value);
@@ -4364,7 +4427,7 @@
 	  return result;
 	};
 	var _activateContainerAsync = function _activateContainerAsync(activationsIterator, context, resultPromise) {
-	  return __awaiter$2(void 0, void 0, void 0, function () {
+	  return __awaiter$1(void 0, void 0, void 0, function () {
 	    var result, activation;
 	    return __generator$1(this, function (_a) {
 	      switch (_a.label) {
@@ -4978,7 +5041,7 @@
 	  };
 	  return __assign.apply(this, arguments);
 	};
-	var __awaiter$1 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
+	var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
 	  function adopt(value) {
 	    return value instanceof P ? value : new P(function (resolve) {
 	      resolve(value);
@@ -5177,7 +5240,7 @@
 	    for (var _i = 0; _i < arguments.length; _i++) {
 	      modules[_i] = arguments[_i];
 	    }
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var getHelpers, _a, modules_2, currentModule, containerModuleHelpers;
 	      return __generator(this, function (_b) {
 	        switch (_b.label) {
@@ -5219,7 +5282,7 @@
 	    for (var _i = 0; _i < arguments.length; _i++) {
 	      modules[_i] = arguments[_i];
 	    }
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var _a, modules_3, module_1, deactivations;
 	      return __generator(this, function (_b) {
 	        switch (_b.label) {
@@ -5255,7 +5318,7 @@
 	    return this.bind(serviceIdentifier);
 	  };
 	  Container.prototype.rebindAsync = function (serviceIdentifier) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
 	          case 0:
@@ -5275,7 +5338,7 @@
 	    this._removeServiceFromDictionary(serviceIdentifier);
 	  };
 	  Container.prototype.unbindAsync = function (serviceIdentifier) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var bindings;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
@@ -5301,7 +5364,7 @@
 	    this._bindingDictionary = new Lookup();
 	  };
 	  Container.prototype.unbindAllAsync = function () {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var promises;
 	      var _this = this;
 	      return __generator(this, function (_a) {
@@ -5390,7 +5453,7 @@
 	    return this._getButThrowIfAsync(getArgs);
 	  };
 	  Container.prototype.getAsync = function (serviceIdentifier) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var getArgs;
 	      return __generator(this, function (_a) {
 	        getArgs = this._getNotAllArgs(serviceIdentifier, false);
@@ -5403,7 +5466,7 @@
 	    return this._getButThrowIfAsync(getArgs);
 	  };
 	  Container.prototype.getTaggedAsync = function (serviceIdentifier, key, value) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var getArgs;
 	      return __generator(this, function (_a) {
 	        getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);
@@ -5487,7 +5550,7 @@
 	    }
 	  };
 	  Container.prototype._handleDeactivationError = function (asyncResult, constructor) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var ex_1;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
@@ -5520,7 +5583,7 @@
 	    }
 	  };
 	  Container.prototype._deactivateContainerAsync = function (instance, deactivationsIterator) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var deactivation;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
@@ -5673,7 +5736,7 @@
 	    }
 	  };
 	  Container.prototype._deactivateSingletonsAsync = function (bindings) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      var _this = this;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
@@ -5696,7 +5759,7 @@
 	    }
 	  };
 	  Container.prototype._propagateContainerDeactivationThenBindingAndPreDestroyAsync = function (binding, instance, constructor) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
 	          case 0:
@@ -5736,7 +5799,7 @@
 	    return this._preDestroy(constructor, instance);
 	  };
 	  Container.prototype._bindingDeactivationAndPreDestroyAsync = function (binding, instance, constructor) {
-	    return __awaiter$1(this, void 0, void 0, function () {
+	    return __awaiter(this, void 0, void 0, function () {
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
 	          case 0:
@@ -5907,33 +5970,6 @@
 	function __metadata(metadataKey, metadataValue) {
 	  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 	}
-	function __awaiter(thisArg, _arguments, P, generator) {
-	  function adopt(value) {
-	    return value instanceof P ? value : new P(function (resolve) {
-	      resolve(value);
-	    });
-	  }
-	  return new (P || (P = Promise))(function (resolve, reject) {
-	    function fulfilled(value) {
-	      try {
-	        step(generator.next(value));
-	      } catch (e) {
-	        reject(e);
-	      }
-	    }
-	    function rejected(value) {
-	      try {
-	        step(generator["throw"](value));
-	      } catch (e) {
-	        reject(e);
-	      }
-	    }
-	    function step(result) {
-	      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-	    }
-	    step((generator = generator.apply(thisArg, _arguments || [])).next());
-	  });
-	}
 	typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
 	  var e = new Error(message);
 	  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -6268,6 +6304,24 @@
 	        }
 	        return this._env === 'browser' && /Safari/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent);
 	    }
+	    getNativeAABBBounds(dom) {
+	        if (!this._env) {
+	            this.setEnv('browser');
+	        }
+	        return this.envContribution.getNativeAABBBounds(dom);
+	    }
+	    removeDom(dom) {
+	        if (!this._env) {
+	            this.setEnv('browser');
+	        }
+	        return this.envContribution.removeDom(dom);
+	    }
+	    createDom(params) {
+	        if (!this._env) {
+	            this.setEnv('browser');
+	        }
+	        return this.envContribution.createDom(params);
+	    }
 	};
 	exports.DefaultGlobal = __decorate([
 	    injectable(),
@@ -9233,7 +9287,11 @@
 	    strokeBoundsBuffer: 2,
 	    stroke: false
 	};
-	const DefaultStrokeStyle = Object.assign({ outerBorder: Object.assign(Object.assign({}, commonStroke), { distance: 0 }), innerBorder: Object.assign(Object.assign({}, commonStroke), { distance: 0 }) }, commonStroke);
+	const DefaultStrokeStyle = {
+	    outerBorder: { ...commonStroke, distance: 0 },
+	    innerBorder: { ...commonStroke, distance: 0 },
+	    ...commonStroke
+	};
 	const DefaultTextStyle = {
 	    text: '',
 	    maxLineWidth: Infinity,
@@ -9253,14 +9311,42 @@
 	    direction: 'horizontal',
 	    wordBreak: 'break-all'
 	};
-	const DefaultStyle = Object.assign(Object.assign(Object.assign({ opacity: 1, background: null, texture: null, textureColor: 'black', textureSize: 10, texturePadding: 2, backgroundMode: 0, blur: 0, cursor: null }, DefaultFillStyle), DefaultStrokeStyle), DefaultLayout);
+	const DefaultStyle = {
+	    opacity: 1,
+	    background: null,
+	    texture: null,
+	    textureColor: 'black',
+	    textureSize: 10,
+	    texturePadding: 2,
+	    backgroundMode: 0,
+	    blur: 0,
+	    cursor: null,
+	    html: null,
+	    ...DefaultFillStyle,
+	    ...DefaultStrokeStyle,
+	    ...DefaultLayout
+	};
 	const DefaultConnectAttribute = {
 	    connectedType: 'none',
 	    connectedStyle: {},
 	    connectedX: NaN,
 	    connectedY: NaN
 	};
-	const DefaultAttribute = Object.assign(Object.assign({ strokeSeg: null, pickable: true, childrenPickable: true, visible: true, zIndex: 0, layout: null, boundsPadding: 0, pickMode: 'accurate', customPickShape: null, boundsMode: 'accurate', keepDirIn3d: true }, DefaultStyle), DefaultTransform);
+	const DefaultAttribute = {
+	    strokeSeg: null,
+	    pickable: true,
+	    childrenPickable: true,
+	    visible: true,
+	    zIndex: 0,
+	    layout: null,
+	    boundsPadding: 0,
+	    pickMode: 'accurate',
+	    customPickShape: null,
+	    boundsMode: 'accurate',
+	    keepDirIn3d: true,
+	    ...DefaultStyle,
+	    ...DefaultTransform
+	};
 	function addAttributeToPrototype(obj, c, keys) {
 	    keys.forEach(key => {
 	        c.prototype[key] = obj[key];
@@ -9269,23 +9355,145 @@
 	function rewriteProto(obj, c) {
 	    Object.setPrototypeOf(obj, c);
 	}
-	const DefaultArcAttribute = Object.assign(Object.assign({}, DefaultAttribute), { startAngle: 0, endAngle: pi2, innerRadius: 0, outerRadius: 1, cornerRadius: 0, padRadius: 0, padAngle: 0, cap: false, forceShowCap: false });
-	const DefaultAreaAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultConnectAttribute), { points: [], segments: [], curveType: 'linear', clipRange: 1 });
-	const DefaultCircleAttribute = Object.assign(Object.assign({}, DefaultAttribute), { radius: 1, startAngle: 0, endAngle: pi2 });
-	const DefaultGroupAttribute = Object.assign(Object.assign({}, DefaultAttribute), { width: 0, height: 0, cornerRadius: 0, path: [], clip: false, visibleAll: true, display: 'relative', flexDirection: 'row', flexWrap: 'wrap', justifyContent: 'flex-start', alignItems: 'flex-start', alignContent: 'flex-start' });
-	const DefaultGlyphAttribute = Object.assign(Object.assign({}, DefaultAttribute), { path: '', width: 0, height: 0, cornerRadius: 0, clip: false });
-	const DefaultLineAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultConnectAttribute), { points: [], segments: [], curveType: 'linear', clipRange: 1, clipRangeByDimension: 'default' });
-	const DefaultPathAttribute = Object.assign(Object.assign({}, DefaultAttribute), { path: new CustomPath2D(), customPath: () => {
+	const DefaultArcAttribute = {
+	    ...DefaultAttribute,
+	    startAngle: 0,
+	    endAngle: pi2,
+	    innerRadius: 0,
+	    outerRadius: 1,
+	    cornerRadius: 0,
+	    padRadius: 0,
+	    padAngle: 0,
+	    cap: false,
+	    forceShowCap: false
+	};
+	const DefaultAreaAttribute = {
+	    ...DefaultAttribute,
+	    ...DefaultConnectAttribute,
+	    points: [],
+	    segments: [],
+	    curveType: 'linear',
+	    clipRange: 1
+	};
+	const DefaultCircleAttribute = {
+	    ...DefaultAttribute,
+	    radius: 1,
+	    startAngle: 0,
+	    endAngle: pi2
+	};
+	const DefaultGroupAttribute = {
+	    ...DefaultAttribute,
+	    width: 0,
+	    height: 0,
+	    cornerRadius: 0,
+	    path: [],
+	    clip: false,
+	    visibleAll: true,
+	    display: 'relative',
+	    flexDirection: 'row',
+	    flexWrap: 'wrap',
+	    justifyContent: 'flex-start',
+	    alignItems: 'flex-start',
+	    alignContent: 'flex-start'
+	};
+	const DefaultGlyphAttribute = {
+	    ...DefaultAttribute,
+	    path: '',
+	    width: 0,
+	    height: 0,
+	    cornerRadius: 0,
+	    clip: false
+	};
+	const DefaultLineAttribute = {
+	    ...DefaultAttribute,
+	    ...DefaultConnectAttribute,
+	    points: [],
+	    segments: [],
+	    curveType: 'linear',
+	    clipRange: 1,
+	    clipRangeByDimension: 'default'
+	};
+	const DefaultPathAttribute = {
+	    ...DefaultAttribute,
+	    path: new CustomPath2D(),
+	    customPath: () => {
 	        console.warn('空函数');
-	    } });
-	const DefaultPolygonAttribute = Object.assign(Object.assign({}, DefaultAttribute), { points: [], cornerRadius: 0 });
-	const DefaultRectAttribute = Object.assign(Object.assign({}, DefaultAttribute), { width: 0, height: 0, strokeBoundsBuffer: 0, cornerRadius: 0 });
-	const DefaultRect3dAttribute = Object.assign(Object.assign({}, DefaultAttribute), { width: 0, height: 0, cornerRadius: 0, length: 0 });
-	const DefaultSymbolAttribute = Object.assign(Object.assign({}, DefaultAttribute), { symbolType: 'circle', size: 10, keepDirIn3d: true });
-	const DefaultTextAttribute = Object.assign(Object.assign(Object.assign({}, DefaultAttribute), DefaultTextStyle), { strokeBoundsBuffer: 0, keepDirIn3d: true });
-	const DefaultRichTextAttribute = Object.assign(Object.assign({}, DefaultAttribute), { width: 300, height: 300, ellipsis: true, wordBreak: 'break-word', verticalDirection: 'top', textAlign: 'left', textBaseline: 'top', layoutDirection: 'horizontal', textConfig: [], maxHeight: undefined, maxWidth: undefined, singleLine: false });
-	const DefaultImageAttribute = Object.assign(Object.assign({ repeatX: 'no-repeat', repeatY: 'no-repeat', image: '', width: 0, height: 0 }, DefaultAttribute), { fill: true });
-	const DefaultRichTextIconAttribute = Object.assign(Object.assign({}, DefaultImageAttribute), { backgroundShowMode: 'never', backgroundWidth: 0, backgroundHeight: 0, textAlign: 'left', textBaseline: 'middle', direction: 'horizontal', margin: 0, id: '', width: 20, height: 20, backgroundFill: 'rgba(101, 117, 168, 0.1)', backgroundFillOpacity: 1, backgroundStroke: false, backgroundStrokeOpacity: 1, backgroundRadius: 4, opacity: 1 });
+	    }
+	};
+	const DefaultPolygonAttribute = {
+	    ...DefaultAttribute,
+	    points: [],
+	    cornerRadius: 0
+	};
+	const DefaultRectAttribute = {
+	    ...DefaultAttribute,
+	    width: 0,
+	    height: 0,
+	    strokeBoundsBuffer: 0,
+	    cornerRadius: 0
+	};
+	const DefaultRect3dAttribute = {
+	    ...DefaultAttribute,
+	    width: 0,
+	    height: 0,
+	    cornerRadius: 0,
+	    length: 0
+	};
+	const DefaultSymbolAttribute = {
+	    ...DefaultAttribute,
+	    symbolType: 'circle',
+	    size: 10,
+	    keepDirIn3d: true
+	};
+	const DefaultTextAttribute = {
+	    ...DefaultAttribute,
+	    ...DefaultTextStyle,
+	    strokeBoundsBuffer: 0,
+	    keepDirIn3d: true
+	};
+	const DefaultRichTextAttribute = {
+	    ...DefaultAttribute,
+	    width: 300,
+	    height: 300,
+	    ellipsis: true,
+	    wordBreak: 'break-word',
+	    verticalDirection: 'top',
+	    textAlign: 'left',
+	    textBaseline: 'top',
+	    layoutDirection: 'horizontal',
+	    textConfig: [],
+	    maxHeight: undefined,
+	    maxWidth: undefined,
+	    singleLine: false
+	};
+	const DefaultImageAttribute = {
+	    repeatX: 'no-repeat',
+	    repeatY: 'no-repeat',
+	    image: '',
+	    width: 0,
+	    height: 0,
+	    ...DefaultAttribute,
+	    fill: true
+	};
+	const DefaultRichTextIconAttribute = {
+	    ...DefaultImageAttribute,
+	    backgroundShowMode: 'never',
+	    backgroundWidth: 0,
+	    backgroundHeight: 0,
+	    textAlign: 'left',
+	    textBaseline: 'middle',
+	    direction: 'horizontal',
+	    margin: 0,
+	    id: '',
+	    width: 20,
+	    height: 20,
+	    backgroundFill: 'rgba(101, 117, 168, 0.1)',
+	    backgroundFillOpacity: 1,
+	    backgroundStroke: false,
+	    backgroundStrokeOpacity: 1,
+	    backgroundRadius: 4,
+	    opacity: 1
+	};
 
 	class Application {
 	}
@@ -9535,7 +9743,7 @@
 	                    clipedData.width = this.measureTextWidth(clipedData.str, options);
 	                }
 	            }
-	            out.push(Object.assign(Object.assign({}, verticalList[i]), { text: clipedData.str, width: clipedData.width }));
+	            out.push({ ...verticalList[i], text: clipedData.str, width: clipedData.width });
 	            length += clipedData.width;
 	        }
 	        return {
@@ -10420,10 +10628,16 @@
 	    }
 	    createTextMeasureInstance(textSpec, option, getCanvasForMeasure) {
 	        this.configure(this.global, this.global.env);
-	        return new TextMeasure(Object.assign({ defaultFontParams: {
+	        return new TextMeasure({
+	            defaultFontParams: {
 	                fontFamily: DefaultTextStyle.fontFamily,
 	                fontSize: DefaultTextStyle.fontSize
-	            }, getCanvasForMeasure: getCanvasForMeasure || (() => this.canvas), getTextBounds: undefined, specialCharSet: '-/: .,@%\'"~' + TextMeasure.ALPHABET_CHAR_SET + TextMeasure.ALPHABET_CHAR_SET.toUpperCase() }, (option !== null && option !== void 0 ? option : {})), textSpec);
+	            },
+	            getCanvasForMeasure: getCanvasForMeasure || (() => this.canvas),
+	            getTextBounds: undefined,
+	            specialCharSet: '-/: .,@%\'"~' + TextMeasure.ALPHABET_CHAR_SET + TextMeasure.ALPHABET_CHAR_SET.toUpperCase(),
+	            ...(option !== null && option !== void 0 ? option : {})
+	        }, textSpec);
 	    }
 	};
 	exports.DefaultGraphicUtil = __decorate([
@@ -10800,37 +11014,35 @@
 	            }
 	        }
 	    }
-	    forEachChildrenAsync(cb, reverse = false) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            if (reverse) {
-	                let child = this._lastChild;
-	                let i = 0;
-	                while (child) {
-	                    let breakTag = cb(child, i++);
-	                    if (breakTag.then) {
-	                        breakTag = yield breakTag;
-	                    }
-	                    if (breakTag) {
-	                        return;
-	                    }
-	                    child = child._prev;
+	    async forEachChildrenAsync(cb, reverse = false) {
+	        if (reverse) {
+	            let child = this._lastChild;
+	            let i = 0;
+	            while (child) {
+	                let breakTag = cb(child, i++);
+	                if (breakTag.then) {
+	                    breakTag = await breakTag;
 	                }
+	                if (breakTag) {
+	                    return;
+	                }
+	                child = child._prev;
 	            }
-	            else {
-	                let child = this._firstChild;
-	                let i = 0;
-	                while (child) {
-	                    let breakTag = cb(child, i++);
-	                    if (breakTag.then) {
-	                        breakTag = yield breakTag;
-	                    }
-	                    if (breakTag) {
-	                        return;
-	                    }
-	                    child = child._next;
+	        }
+	        else {
+	            let child = this._firstChild;
+	            let i = 0;
+	            while (child) {
+	                let breakTag = cb(child, i++);
+	                if (breakTag.then) {
+	                    breakTag = await breakTag;
 	                }
+	                if (breakTag) {
+	                    return;
+	                }
+	                child = child._next;
 	            }
-	        });
+	        }
 	    }
 	    forEach(cb) {
 	        return this.forEachChildren(cb);
@@ -14521,7 +14733,16 @@
 	        var _a;
 	        const root = this.target.attachShadow();
 	        const height = this.target.AABBBounds.height();
-	        const rect = application.graphicService.creator.rect(Object.assign(Object.assign({ height: height, fill: '#bcdeff', shadowBlur: 30, shadowColor: '#bcdeff' }, (_a = this.params) === null || _a === void 0 ? void 0 : _a.attribute), { x: 0, y: 0, width: 0 }));
+	        const rect = application.graphicService.creator.rect({
+	            height: height,
+	            fill: '#bcdeff',
+	            shadowBlur: 30,
+	            shadowColor: '#bcdeff',
+	            ...(_a = this.params) === null || _a === void 0 ? void 0 : _a.attribute,
+	            x: 0,
+	            y: 0,
+	            width: 0
+	        });
 	        this.rect = rect;
 	        root.add(rect);
 	    }
@@ -16284,7 +16505,10 @@
 	    if (fromGradient !== toGradient) {
 	        const gradient = (fromGradient ? from : to);
 	        const pure = (fromGradient ? to : from);
-	        const gradientFromPure = Object.assign(Object.assign({}, gradient), { stops: gradient.stops.map(v => (Object.assign(Object.assign({}, v), { color: colorArrayToString(pure) }))) });
+	        const gradientFromPure = {
+	            ...gradient,
+	            stops: gradient.stops.map(v => ({ ...v, color: colorArrayToString(pure) }))
+	        };
 	        return fromGradient
 	            ? interpolateColor(gradient, gradientFromPure, ratio, alphaChannel, cb)
 	            : interpolateColor(gradientFromPure, gradient, ratio, alphaChannel, cb);
@@ -17870,33 +18094,31 @@
 	function incrementalAddTo(group, graphic) {
 	    group.incrementalAppendChild(graphic);
 	}
-	function waitForAllSubLayers(stage) {
-	    return __awaiter(this, void 0, void 0, function* () {
-	        const promiseList = [];
-	        const layers = stage.getChildren();
-	        yield new Promise(resolve => {
-	            application.global.getRequestAnimationFrame()(() => {
-	                resolve(null);
-	            });
+	async function waitForAllSubLayers(stage) {
+	    const promiseList = [];
+	    const layers = stage.getChildren();
+	    await new Promise(resolve => {
+	        application.global.getRequestAnimationFrame()(() => {
+	            resolve(null);
 	        });
-	        layers.forEach(l => {
-	            if (l.subLayers.size) {
-	                l.subLayers.forEach(sl => {
-	                    if (sl.drawContribution && sl.drawContribution.hooks && sl.drawContribution.rendering) {
-	                        promiseList.push(new Promise(resolve => {
-	                            sl.drawContribution.hooks.completeDraw.tap('outWait', () => {
-	                                sl.drawContribution.hooks.completeDraw.taps = sl.drawContribution.hooks.completeDraw.taps.filter(i => {
-	                                    return i.name !== 'outWait';
-	                                });
-	                                resolve(null);
+	    });
+	    layers.forEach(l => {
+	        if (l.subLayers.size) {
+	            l.subLayers.forEach(sl => {
+	                if (sl.drawContribution && sl.drawContribution.hooks && sl.drawContribution.rendering) {
+	                    promiseList.push(new Promise(resolve => {
+	                        sl.drawContribution.hooks.completeDraw.tap('outWait', () => {
+	                            sl.drawContribution.hooks.completeDraw.taps = sl.drawContribution.hooks.completeDraw.taps.filter(i => {
+	                                return i.name !== 'outWait';
 	                            });
-	                        }));
-	                    }
-	                });
-	            }
-	        });
-	        yield Promise.all(promiseList);
+	                            resolve(null);
+	                        });
+	                    }));
+	                }
+	            });
+	        }
 	    });
+	    await Promise.all(promiseList);
 	}
 	function boundStroke(bounds, halfW, miter, pad = 0) {
 	    bounds.expand(halfW + (pad / 2 + (miter ? miterAdjustment(miter, halfW) : 0)));
@@ -17990,6 +18212,28 @@
 	const TEXT_NUMBER_TYPE = genNumberType();
 	const GraphicService = Symbol.for('GraphicService');
 	const GraphicCreator = Symbol.for('GraphicCreator');
+	const SVG_ATTRIBUTE_MAP = {
+	    'stroke-linecap': 'lineCap',
+	    'stroke-linejoin': 'lineJoin',
+	    'stroke-dasharray': 'lineDash',
+	    'stroke-dashoffset': 'lineDashOffset',
+	    'stroke-width': 'lineWidth',
+	    'fill-opacity': 'fillOpacity',
+	    'stroke-opacity': 'strokeOpacity'
+	};
+	const SVG_ATTRIBUTE_MAP_KEYS = Object.keys(SVG_ATTRIBUTE_MAP);
+	const SVG_PARSE_ATTRIBUTE_MAP = {
+	    '@_stroke-linecap': 'lineCap',
+	    '@_stroke-linejoin': 'lineJoin',
+	    '@_stroke-dasharray': 'lineDash',
+	    '@_stroke-dashoffset': 'lineDashOffset',
+	    '@_stroke-width': 'lineWidth',
+	    '@_fill-opacity': 'fillOpacity',
+	    '@_stroke-opacity': 'strokeOpacity',
+	    '@_stroke': 'stroke',
+	    '@_fill': 'fill'
+	};
+	const SVG_PARSE_ATTRIBUTE_MAP_KEYS = Object.keys(SVG_PARSE_ATTRIBUTE_MAP);
 
 	exports.GroupUpdateAABBBoundsMode = void 0;
 	(function (GroupUpdateAABBBoundsMode) {
@@ -18240,7 +18484,7 @@
 	        return graphic;
 	    }
 	    clone() {
-	        return new Group(Object.assign({}, this.attribute));
+	        return new Group({ ...this.attribute });
 	    }
 	}
 
@@ -18370,7 +18614,17 @@
 	    combineTo(target, params) {
 	        var _a;
 	        if (this.offscreen) {
-	            this.layerHandler.drawTo(target, [this], Object.assign({ background: (_a = params.background) !== null && _a !== void 0 ? _a : this.background, renderService: params.renderService, x: this.stage.x, y: this.stage.y, width: this.viewWidth, height: this.viewHeight, stage: this.stage, layer: this }, params));
+	            this.layerHandler.drawTo(target, [this], {
+	                background: (_a = params.background) !== null && _a !== void 0 ? _a : this.background,
+	                renderService: params.renderService,
+	                x: this.stage.x,
+	                y: this.stage.y,
+	                width: this.viewWidth,
+	                height: this.viewHeight,
+	                stage: this.stage,
+	                layer: this,
+	                ...params
+	            });
 	            this.afterDrawCbs.forEach(c => c(this));
 	        }
 	    }
@@ -18385,7 +18639,17 @@
 	    }
 	    drawTo(target, params) {
 	        var _a;
-	        this.layerHandler.drawTo(target, [this], Object.assign({ background: (_a = params.background) !== null && _a !== void 0 ? _a : this.background, renderService: params.renderService, x: this.stage.x, y: this.stage.y, width: this.viewWidth, height: this.viewHeight, stage: this.stage, layer: this }, params));
+	        this.layerHandler.drawTo(target, [this], {
+	            background: (_a = params.background) !== null && _a !== void 0 ? _a : this.background,
+	            renderService: params.renderService,
+	            x: this.stage.x,
+	            y: this.stage.y,
+	            width: this.viewWidth,
+	            height: this.viewHeight,
+	            stage: this.stage,
+	            layer: this,
+	            ...params
+	        });
 	        this.afterDrawCbs.forEach(c => c(this));
 	    }
 	}
@@ -18407,7 +18671,10 @@
 	    }
 	    createLayer(stage, options = { main: false }) {
 	        this.tryInit();
-	        const layer = new Layer(stage, this.global, stage.window, Object.assign(Object.assign({}, options), { virtual: this.staticLayerCountInEnv === 0 }));
+	        const layer = new Layer(stage, this.global, stage.window, {
+	            ...options,
+	            virtual: this.staticLayerCountInEnv === 0
+	        });
 	        const stageLayers = this.layerMap.get(stage) || [];
 	        stageLayers.push(layer);
 	        this.layerMap.set(stage, stageLayers);
@@ -19496,7 +19763,7 @@
 	        return path;
 	    }
 	    clone() {
-	        return new Circle(Object.assign({}, this.attribute));
+	        return new Circle({ ...this.attribute });
 	    }
 	}
 
@@ -20021,7 +20288,7 @@
 	        return false;
 	    }
 	    clone() {
-	        return new Text(Object.assign({}, this.attribute));
+	        return new Text({ ...this.attribute });
 	    }
 	}
 
@@ -20562,7 +20829,7 @@
 	class Arrow2LeftSymbol {
 	    constructor() {
 	        this.type = 'arrow2Left';
-	        this.pathStr = 'M 0.25 -0.5 L -0.25 0 l 0.5 0.5';
+	        this.pathStr = 'M 0.25 -0.5 L -0.25 0 l 0.25 0.5';
 	    }
 	    draw(ctx, size, transX, transY) {
 	        const r = size / 4;
@@ -20592,7 +20859,7 @@
 	class Arrow2RightSymbol {
 	    constructor() {
 	        this.type = 'arrow2Right';
-	        this.pathStr = 'M -0.25 -0.5 l 0.5 0.5 l -0.5 0.5';
+	        this.pathStr = 'M -0.25 -0.5 l 0.25 0 l -0.25 0.5';
 	    }
 	    draw(ctx, size, transX, transY) {
 	        const r = size / 4;
@@ -20612,6 +20879,164 @@
 	}
 	var arrow2Right$1 = new Arrow2RightSymbol();
 
+	function arrow2Up(ctx, r, transX, transY) {
+	    const r2 = r * 2;
+	    ctx.moveTo(transX - r2, transY + r);
+	    ctx.lineTo(transX, transY - r);
+	    ctx.lineTo(transX + r2, transY + r);
+	    return true;
+	}
+	class Arrow2UpSymbol {
+	    constructor() {
+	        this.type = 'arrow2Up';
+	        this.pathStr = 'M -0.5 0.25 L 0 -0.25 l 0.5 0.25';
+	    }
+	    draw(ctx, size, transX, transY) {
+	        const r = size / 4;
+	        return arrow2Up(ctx, r, transX, transY);
+	    }
+	    drawOffset(ctx, size, transX, transY, offset) {
+	        const r = size / 4 + offset;
+	        return arrow2Up(ctx, r, transX, transY);
+	    }
+	    bounds(size, bounds) {
+	        const r = size / 2;
+	        bounds.x1 = -r;
+	        bounds.x2 = r;
+	        bounds.y1 = -r;
+	        bounds.y2 = r;
+	    }
+	}
+	var arrow2Up$1 = new Arrow2UpSymbol();
+
+	function arrow2Down(ctx, r, transX, transY) {
+	    const r2 = r * 2;
+	    ctx.moveTo(transX - r2, transY - r);
+	    ctx.lineTo(transX, transY + r);
+	    ctx.lineTo(transX + r2, transY - r);
+	    return true;
+	}
+	class Arrow2DownSymbol {
+	    constructor() {
+	        this.type = 'arrow2Down';
+	        this.pathStr = 'M -0.5 -0.25 L 0 0.25 l 0.5 -0.25';
+	    }
+	    draw(ctx, size, transX, transY) {
+	        const r = size / 4;
+	        return arrow2Down(ctx, r, transX, transY);
+	    }
+	    drawOffset(ctx, size, transX, transY, offset) {
+	        const r = size / 4 + offset;
+	        return arrow2Down(ctx, r, transX, transY);
+	    }
+	    bounds(size, bounds) {
+	        const r = size / 2;
+	        bounds.x1 = -r;
+	        bounds.x2 = r;
+	        bounds.y1 = -r;
+	        bounds.y2 = r;
+	    }
+	}
+	var arrow2Down$1 = new Arrow2DownSymbol();
+
+	function lineV(ctx, r, x, y, z) {
+	    ctx.moveTo(x, y - r);
+	    ctx.lineTo(x, y + r);
+	    return true;
+	}
+	class LineVSymbol {
+	    constructor() {
+	        this.type = 'lineV';
+	        this.pathStr = 'M0,-0.5L0,0.5';
+	    }
+	    draw(ctx, size, x, y, z) {
+	        const r = size / 2;
+	        return lineV(ctx, r, x, y);
+	    }
+	    drawOffset(ctx, size, x, y, offset, z) {
+	        const r = size / 2 + offset;
+	        return lineV(ctx, r, x, y);
+	    }
+	    drawToSvgPath(size, x, y, z) {
+	        const r = size / 2;
+	        return `M ${x}, ${y - r} L ${x},${y + r}`;
+	    }
+	    bounds(size, bounds) {
+	        const r = size / 2;
+	        bounds.x1 = -r;
+	        bounds.x2 = r;
+	        bounds.y1 = -r;
+	        bounds.y2 = r;
+	    }
+	}
+	var lineV$1 = new LineVSymbol();
+
+	function lineH(ctx, r, x, y, z) {
+	    ctx.moveTo(x - r, y);
+	    ctx.lineTo(x + r, y);
+	    return true;
+	}
+	class LineHSymbol {
+	    constructor() {
+	        this.type = 'lineH';
+	        this.pathStr = 'M-0.5,0L0.5,0';
+	    }
+	    draw(ctx, size, x, y, z) {
+	        const r = size / 2;
+	        return lineH(ctx, r, x, y);
+	    }
+	    drawOffset(ctx, size, x, y, offset, z) {
+	        const r = size / 2 + offset;
+	        return lineH(ctx, r, x, y);
+	    }
+	    drawToSvgPath(size, x, y, z) {
+	        const r = size / 2;
+	        return `M ${x - r}, ${y} L ${x + r},${y}`;
+	    }
+	    bounds(size, bounds) {
+	        const r = size / 2;
+	        bounds.x1 = -r;
+	        bounds.x2 = r;
+	        bounds.y1 = -r;
+	        bounds.y2 = r;
+	    }
+	}
+	var lineH$1 = new LineHSymbol();
+
+	function close(ctx, r, x, y, z) {
+	    ctx.moveTo(x - r, y - r);
+	    ctx.lineTo(x + r, y + r);
+	    ctx.moveTo(x + r, y - r);
+	    ctx.lineTo(x - r, y + r);
+	    return true;
+	}
+	class CloseSymbol {
+	    constructor() {
+	        this.type = 'close';
+	        this.pathStr = 'M-0.5,-0.5L0.5,0.5,M0.5,-0.5L-0.5,0.5';
+	    }
+	    draw(ctx, size, x, y, z) {
+	        const r = size / 2;
+	        return close(ctx, r, x, y);
+	    }
+	    drawOffset(ctx, size, x, y, offset, z) {
+	        const r = size / 2 + offset;
+	        return close(ctx, r, x, y);
+	    }
+	    drawToSvgPath(size, x, y, z) {
+	        const r = size / 2;
+	        return `M ${x - r}, ${y - r} L ${x + r},${y + r} M ${x + r}, ${y - r} L ${x - r},${y + r}`;
+	    }
+	    bounds(size, bounds) {
+	        const r = size / 2;
+	        bounds.x1 = -r;
+	        bounds.x2 = r;
+	        bounds.y1 = -r;
+	        bounds.y2 = r;
+	    }
+	}
+	var close$1 = new CloseSymbol();
+
 	function rect(ctx, size, x, y) {
 	    ctx.rect(x - size[0] / 2, y - size[1] / 2, size[0], size[1]);
 	    return false;
@@ -20641,21 +21066,64 @@
 	}
 	var rect$1 = new RectSymbol();
 
+	const tempBounds = new AABBBounds();
 	class CustomSymbolClass {
-	    constructor(type, path) {
+	    constructor(type, path, isSvg = false) {
 	        this.pathStr = '';
 	        this.type = type;
-	        this.path = path;
+	        if (isArray(path)) {
+	            this.svgCache = path;
+	        }
+	        else {
+	            this.path = path;
+	        }
+	        this.isSvg = isSvg;
 	    }
-	    drawOffset(ctx, size, x, y, offset) {
+	    drawOffset(ctx, size, x, y, offset, z, cb) {
+	        if (this.isSvg) {
+	            if (!this.svgCache) {
+	                return false;
+	            }
+	            this.svgCache.forEach(item => {
+	                ctx.beginPath();
+	                renderCommandList(item.path.commandList, ctx, x, y, size, size);
+	                cb && cb(item.path, item.attribute);
+	            });
+	            return false;
+	        }
 	        renderCommandList(this.path.commandList, ctx, x, y, size + offset, size + offset);
 	        return false;
 	    }
-	    draw(ctx, size, x, y) {
+	    draw(ctx, size, x, y, z, cb) {
+	        if (this.isSvg) {
+	            if (!this.svgCache) {
+	                return false;
+	            }
+	            this.svgCache.forEach(item => {
+	                ctx.beginPath();
+	                renderCommandList(item.path.commandList, ctx, x, y, size, size);
+	                cb && cb(item.path, item.attribute);
+	            });
+	            return false;
+	        }
 	        renderCommandList(this.path.commandList, ctx, x, y, size, size);
 	        return false;
 	    }
 	    bounds(size, bounds) {
+	        if (this.isSvg) {
+	            if (!this.svgCache) {
+	                return;
+	            }
+	            bounds.clear();
+	            this.svgCache.forEach(({ path }) => {
+	                tempBounds.x1 = path.bounds.x1 * size;
+	                tempBounds.y1 = path.bounds.y1 * size;
+	                tempBounds.x2 = path.bounds.x2 * size;
+	                tempBounds.y2 = path.bounds.y2 * size;
+	                bounds.union(tempBounds);
+	            });
+	            return;
+	        }
 	        if (!this.path.bounds) {
 	            return;
 	        }
@@ -20684,13 +21152,1892 @@
 	    triangleDown,
 	    arrow2Left$1,
 	    arrow2Right$1,
-	    rect$1
+	    arrow2Up$1,
+	    arrow2Down$1,
+	    rect$1,
+	    lineV$1,
+	    lineH$1,
+	    close$1
 	];
 	const builtinSymbolsMap = {};
 	builtinSymbols.forEach(symbol => {
 	    builtinSymbolsMap[symbol.type] = symbol;
 	});
 
+	var validator$2 = {};
+
+	var util$3 = {};
+
+	(function (exports) {
+
+	  var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
+	  var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+	  var nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*';
+	  var regexName = new RegExp('^' + nameRegexp + '$');
+	  var getAllMatches = function getAllMatches(string, regex) {
+	    var matches = [];
+	    var match = regex.exec(string);
+	    while (match) {
+	      var allmatches = [];
+	      allmatches.startIndex = regex.lastIndex - match[0].length;
+	      var len = match.length;
+	      for (var index = 0; index < len; index++) {
+	        allmatches.push(match[index]);
+	      }
+	      matches.push(allmatches);
+	      match = regex.exec(string);
+	    }
+	    return matches;
+	  };
+	  var isName = function isName(string) {
+	    var match = regexName.exec(string);
+	    return !(match === null || typeof match === 'undefined');
+	  };
+	  exports.isExist = function (v) {
+	    return typeof v !== 'undefined';
+	  };
+	  exports.isEmptyObject = function (obj) {
+	    return Object.keys(obj).length === 0;
+	  };
+
+	  /**
+	   * Copy all the properties of a into b.
+	   * @param {*} target
+	   * @param {*} a
+	   */
+	  exports.merge = function (target, a, arrayMode) {
+	    if (a) {
+	      var keys = Object.keys(a); // will return an array of own properties
+	      var len = keys.length; //don't make it inline
+	      for (var i = 0; i < len; i++) {
+	        if (arrayMode === 'strict') {
+	          target[keys[i]] = [a[keys[i]]];
+	        } else {
+	          target[keys[i]] = a[keys[i]];
+	        }
+	      }
+	    }
+	  };
+	  /* exports.merge =function (b,a){
+	    return Object.assign(b,a);
+	  } */
+
+	  exports.getValue = function (v) {
+	    if (exports.isExist(v)) {
+	      return v;
+	    } else {
+	      return '';
+	    }
+	  };
+
+	  // const fakeCall = function(a) {return a;};
+	  // const fakeCallNoReturn = function() {};
+
+	  exports.isName = isName;
+	  exports.getAllMatches = getAllMatches;
+	  exports.nameRegexp = nameRegexp;
+	})(util$3);
+
+	var util$2 = util$3;
+	var defaultOptions$2 = {
+	  allowBooleanAttributes: false,
+	  //A tag can have attributes without any value
+	  unpairedTags: []
+	};
+
+	//const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
+	validator$2.validate = function (xmlData, options) {
+	  options = Object.assign({}, defaultOptions$2, options);
+
+	  //xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line
+	  //xmlData = xmlData.replace(/(^\s*<\?xml.*?\?>)/g,"");//Remove XML starting tag
+	  //xmlData = xmlData.replace(/(<!DOCTYPE[\s\w\"\.\/\-\:]+(\[.*\])*\s*>)/g,"");//Remove DOCTYPE
+	  var tags = [];
+	  var tagFound = false;
+
+	  //indicates that the root tag has been closed (aka. depth 0 has been reached)
+	  var reachedRoot = false;
+	  if (xmlData[0] === "\uFEFF") {
+	    // check for byte order mark (BOM)
+	    xmlData = xmlData.substr(1);
+	  }
+	  for (var i = 0; i < xmlData.length; i++) {
+	    if (xmlData[i] === '<' && xmlData[i + 1] === '?') {
+	      i += 2;
+	      i = readPI(xmlData, i);
+	      if (i.err) return i;
+	    } else if (xmlData[i] === '<') {
+	      //starting of tag
+	      //read until you reach to '>' avoiding any '>' in attribute value
+	      var tagStartPos = i;
+	      i++;
+	      if (xmlData[i] === '!') {
+	        i = readCommentAndCDATA(xmlData, i);
+	        continue;
+	      } else {
+	        var closingTag = false;
+	        if (xmlData[i] === '/') {
+	          //closing tag
+	          closingTag = true;
+	          i++;
+	        }
+	        //read tagname
+	        var tagName = '';
+	        for (; i < xmlData.length && xmlData[i] !== '>' && xmlData[i] !== ' ' && xmlData[i] !== '\t' && xmlData[i] !== '\n' && xmlData[i] !== '\r'; i++) {
+	          tagName += xmlData[i];
+	        }
+	        tagName = tagName.trim();
+	        //console.log(tagName);
+
+	        if (tagName[tagName.length - 1] === '/') {
+	          //self closing tag without attributes
+	          tagName = tagName.substring(0, tagName.length - 1);
+	          //continue;
+	          i--;
+	        }
+	        if (!validateTagName(tagName)) {
+	          var msg = void 0;
+	          if (tagName.trim().length === 0) {
+	            msg = "Invalid space after '<'.";
+	          } else {
+	            msg = "Tag '" + tagName + "' is an invalid name.";
+	          }
+	          return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));
+	        }
+	        var result = readAttributeStr(xmlData, i);
+	        if (result === false) {
+	          return getErrorObject('InvalidAttr', "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
+	        }
+	        var attrStr = result.value;
+	        i = result.index;
+	        if (attrStr[attrStr.length - 1] === '/') {
+	          //self closing tag
+	          var attrStrStart = i - attrStr.length;
+	          attrStr = attrStr.substring(0, attrStr.length - 1);
+	          var isValid = validateAttributeString(attrStr, options);
+	          if (isValid === true) {
+	            tagFound = true;
+	            //continue; //text may presents after self closing tag
+	          } else {
+	            //the result from the nested function returns the position of the error within the attribute
+	            //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
+	            //this gives us the absolute index in the entire xml, which we can use to find the line at last
+	            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
+	          }
+	        } else if (closingTag) {
+	          if (!result.tagClosed) {
+	            return getErrorObject('InvalidTag', "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
+	          } else if (attrStr.trim().length > 0) {
+	            return getErrorObject('InvalidTag', "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
+	          } else {
+	            var otg = tags.pop();
+	            if (tagName !== otg.tagName) {
+	              var openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
+	              return getErrorObject('InvalidTag', "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", getLineNumberForPosition(xmlData, tagStartPos));
+	            }
+
+	            //when there are no more tags, we reached the root level.
+	            if (tags.length == 0) {
+	              reachedRoot = true;
+	            }
+	          }
+	        } else {
+	          var _isValid = validateAttributeString(attrStr, options);
+	          if (_isValid !== true) {
+	            //the result from the nested function returns the position of the error within the attribute
+	            //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
+	            //this gives us the absolute index in the entire xml, which we can use to find the line at last
+	            return getErrorObject(_isValid.err.code, _isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + _isValid.err.line));
+	          }
+
+	          //if the root level has been reached before ...
+	          if (reachedRoot === true) {
+	            return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
+	          } else if (options.unpairedTags.indexOf(tagName) !== -1) ; else {
+	            tags.push({
+	              tagName: tagName,
+	              tagStartPos: tagStartPos
+	            });
+	          }
+	          tagFound = true;
+	        }
+
+	        //skip tag text value
+	        //It may include comments and CDATA value
+	        for (i++; i < xmlData.length; i++) {
+	          if (xmlData[i] === '<') {
+	            if (xmlData[i + 1] === '!') {
+	              //comment or CADATA
+	              i++;
+	              i = readCommentAndCDATA(xmlData, i);
+	              continue;
+	            } else if (xmlData[i + 1] === '?') {
+	              i = readPI(xmlData, ++i);
+	              if (i.err) return i;
+	            } else {
+	              break;
+	            }
+	          } else if (xmlData[i] === '&') {
+	            var afterAmp = validateAmpersand(xmlData, i);
+	            if (afterAmp == -1) return getErrorObject('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
+	            i = afterAmp;
+	          } else {
+	            if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
+	              return getErrorObject('InvalidXml', "Extra text at the end", getLineNumberForPosition(xmlData, i));
+	            }
+	          }
+	        } //end of reading tag text value
+	        if (xmlData[i] === '<') {
+	          i--;
+	        }
+	      }
+	    } else {
+	      if (isWhiteSpace(xmlData[i])) {
+	        continue;
+	      }
+	      return getErrorObject('InvalidChar', "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
+	    }
+	  }
+	  if (!tagFound) {
+	    return getErrorObject('InvalidXml', 'Start tag expected.', 1);
+	  } else if (tags.length == 1) {
+	    return getErrorObject('InvalidTag', "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
+	  } else if (tags.length > 0) {
+	    return getErrorObject('InvalidXml', "Invalid '" + JSON.stringify(tags.map(function (t) {
+	      return t.tagName;
+	    }), null, 4).replace(/\r?\n/g, '') + "' found.", {
+	      line: 1,
+	      col: 1
+	    });
+	  }
+	  return true;
+	};
+	function isWhiteSpace(_char) {
+	  return _char === ' ' || _char === '\t' || _char === '\n' || _char === '\r';
+	}
+	/**
+	 * Read Processing insstructions and skip
+	 * @param {*} xmlData
+	 * @param {*} i
+	 */
+	function readPI(xmlData, i) {
+	  var start = i;
+	  for (; i < xmlData.length; i++) {
+	    if (xmlData[i] == '?' || xmlData[i] == ' ') {
+	      //tagname
+	      var tagname = xmlData.substr(start, i - start);
+	      if (i > 5 && tagname === 'xml') {
+	        return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));
+	      } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {
+	        //check if valid attribut string
+	        i++;
+	        break;
+	      } else {
+	        continue;
+	      }
+	    }
+	  }
+	  return i;
+	}
+	function readCommentAndCDATA(xmlData, i) {
+	  if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {
+	    //comment
+	    for (i += 3; i < xmlData.length; i++) {
+	      if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {
+	        i += 2;
+	        break;
+	      }
+	    }
+	  } else if (xmlData.length > i + 8 && xmlData[i + 1] === 'D' && xmlData[i + 2] === 'O' && xmlData[i + 3] === 'C' && xmlData[i + 4] === 'T' && xmlData[i + 5] === 'Y' && xmlData[i + 6] === 'P' && xmlData[i + 7] === 'E') {
+	    var angleBracketsCount = 1;
+	    for (i += 8; i < xmlData.length; i++) {
+	      if (xmlData[i] === '<') {
+	        angleBracketsCount++;
+	      } else if (xmlData[i] === '>') {
+	        angleBracketsCount--;
+	        if (angleBracketsCount === 0) {
+	          break;
+	        }
+	      }
+	    }
+	  } else if (xmlData.length > i + 9 && xmlData[i + 1] === '[' && xmlData[i + 2] === 'C' && xmlData[i + 3] === 'D' && xmlData[i + 4] === 'A' && xmlData[i + 5] === 'T' && xmlData[i + 6] === 'A' && xmlData[i + 7] === '[') {
+	    for (i += 8; i < xmlData.length; i++) {
+	      if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {
+	        i += 2;
+	        break;
+	      }
+	    }
+	  }
+	  return i;
+	}
+	var doubleQuote = '"';
+	var singleQuote = "'";
+
+	/**
+	 * Keep reading xmlData until '<' is found outside the attribute value.
+	 * @param {string} xmlData
+	 * @param {number} i
+	 */
+	function readAttributeStr(xmlData, i) {
+	  var attrStr = '';
+	  var startChar = '';
+	  var tagClosed = false;
+	  for (; i < xmlData.length; i++) {
+	    if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
+	      if (startChar === '') {
+	        startChar = xmlData[i];
+	      } else if (startChar !== xmlData[i]) ; else {
+	        startChar = '';
+	      }
+	    } else if (xmlData[i] === '>') {
+	      if (startChar === '') {
+	        tagClosed = true;
+	        break;
+	      }
+	    }
+	    attrStr += xmlData[i];
+	  }
+	  if (startChar !== '') {
+	    return false;
+	  }
+	  return {
+	    value: attrStr,
+	    index: i,
+	    tagClosed: tagClosed
+	  };
+	}
+
+	/**
+	 * Select all the attributes whether valid or invalid.
+	 */
+	var validAttrStrRegxp = new RegExp('(\\s*)([^\\s=]+)(\\s*=)?(\\s*([\'"])(([\\s\\S])*?)\\5)?', 'g');
+
+	//attr, ="sd", a="amit's", a="sd"b="saf", ab  cd=""
+
+	function validateAttributeString(attrStr, options) {
+	  //console.log("start:"+attrStr+":end");
+
+	  //if(attrStr.trim().length === 0) return true; //empty string
+
+	  var matches = util$2.getAllMatches(attrStr, validAttrStrRegxp);
+	  var attrNames = {};
+	  for (var i = 0; i < matches.length; i++) {
+	    if (matches[i][1].length === 0) {
+	      //nospace before attribute name: a="sd"b="saf"
+	      return getErrorObject('InvalidAttr', "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
+	    } else if (matches[i][3] !== undefined && matches[i][4] === undefined) {
+	      return getErrorObject('InvalidAttr', "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
+	    } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {
+	      //independent attribute: ab
+	      return getErrorObject('InvalidAttr', "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
+	    }
+	    /* else if(matches[i][6] === undefined){//attribute without value: ab=
+	                    return { err: { code:"InvalidAttr",msg:"attribute " + matches[i][2] + " has no value assigned."}};
+	                } */
+	    var attrName = matches[i][2];
+	    if (!validateAttrName(attrName)) {
+	      return getErrorObject('InvalidAttr', "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
+	    }
+	    if (!attrNames.hasOwnProperty(attrName)) {
+	      //check for duplicate attribute.
+	      attrNames[attrName] = 1;
+	    } else {
+	      return getErrorObject('InvalidAttr', "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
+	    }
+	  }
+	  return true;
+	}
+	function validateNumberAmpersand(xmlData, i) {
+	  var re = /\d/;
+	  if (xmlData[i] === 'x') {
+	    i++;
+	    re = /[\da-fA-F]/;
+	  }
+	  for (; i < xmlData.length; i++) {
+	    if (xmlData[i] === ';') return i;
+	    if (!xmlData[i].match(re)) break;
+	  }
+	  return -1;
+	}
+	function validateAmpersand(xmlData, i) {
+	  // https://www.w3.org/TR/xml/#dt-charref
+	  i++;
+	  if (xmlData[i] === ';') return -1;
+	  if (xmlData[i] === '#') {
+	    i++;
+	    return validateNumberAmpersand(xmlData, i);
+	  }
+	  var count = 0;
+	  for (; i < xmlData.length; i++, count++) {
+	    if (xmlData[i].match(/\w/) && count < 20) continue;
+	    if (xmlData[i] === ';') break;
+	    return -1;
+	  }
+	  return i;
+	}
+	function getErrorObject(code, message, lineNumber) {
+	  return {
+	    err: {
+	      code: code,
+	      msg: message,
+	      line: lineNumber.line || lineNumber,
+	      col: lineNumber.col
+	    }
+	  };
+	}
+	function validateAttrName(attrName) {
+	  return util$2.isName(attrName);
+	}
+
+	// const startsWithXML = /^xml/i;
+
+	function validateTagName(tagname) {
+	  return util$2.isName(tagname) /* && !tagname.match(startsWithXML) */;
+	}
+
+	//this function returns the line number for the character at the given index
+	function getLineNumberForPosition(xmlData, index) {
+	  var lines = xmlData.substring(0, index).split(/\r?\n/);
+	  return {
+	    line: lines.length,
+	    // column number is last line's length + 1, because column numbering starts at 1:
+	    col: lines[lines.length - 1].length + 1
+	  };
+	}
+
+	//this function returns the position of the first character of match within attrStr
+	function getPositionFromMatch(match) {
+	  return match.startIndex + match[1].length;
+	}
+
+	var OptionsBuilder = {};
+
+	var defaultOptions$1 = {
+	  preserveOrder: false,
+	  attributeNamePrefix: '@_',
+	  attributesGroupName: false,
+	  textNodeName: '#text',
+	  ignoreAttributes: true,
+	  removeNSPrefix: false,
+	  // remove NS from tag name or attribute name if true
+	  allowBooleanAttributes: false,
+	  //a tag can have attributes without any value
+	  //ignoreRootElement : false,
+	  parseTagValue: true,
+	  parseAttributeValue: false,
+	  trimValues: true,
+	  //Trim string values of tag and attributes
+	  cdataPropName: false,
+	  numberParseOptions: {
+	    hex: true,
+	    leadingZeros: true,
+	    eNotation: true
+	  },
+	  tagValueProcessor: function tagValueProcessor(tagName, val) {
+	    return val;
+	  },
+	  attributeValueProcessor: function attributeValueProcessor(attrName, val) {
+	    return val;
+	  },
+	  stopNodes: [],
+	  //nested tags will not be parsed even for errors
+	  alwaysCreateTextNode: false,
+	  isArray: function isArray() {
+	    return false;
+	  },
+	  commentPropName: false,
+	  unpairedTags: [],
+	  processEntities: true,
+	  htmlEntities: false,
+	  ignoreDeclaration: false,
+	  ignorePiTags: false,
+	  transformTagName: false,
+	  transformAttributeName: false,
+	  updateTag: function updateTag(tagName, jPath, attrs) {
+	    return tagName;
+	  }
+	  // skipEmptyListItem: false
+	};
+
+	var buildOptions$1 = function buildOptions(options) {
+	  return Object.assign({}, defaultOptions$1, options);
+	};
+	OptionsBuilder.buildOptions = buildOptions$1;
+	OptionsBuilder.defaultOptions = defaultOptions$1;
+
+	var XmlNode = /*#__PURE__*/function () {
+	  function XmlNode(tagname) {
+	    _classCallCheck(this, XmlNode);
+	    this.tagname = tagname;
+	    this.child = []; //nested tags, text, cdata, comments in order
+	    this[":@"] = {}; //attributes map
+	  }
+	  _createClass(XmlNode, [{
+	    key: "add",
+	    value: function add(key, val) {
+	      // this.child.push( {name : key, val: val, isCdata: isCdata });
+	      if (key === "__proto__") key = "#__proto__";
+	      this.child.push(_defineProperty({}, key, val));
+	    }
+	  }, {
+	    key: "addChild",
+	    value: function addChild(node) {
+	      if (node.tagname === "__proto__") node.tagname = "#__proto__";
+	      if (node[":@"] && Object.keys(node[":@"]).length > 0) {
+	        var _this$child$push2;
+	        this.child.push((_this$child$push2 = {}, _defineProperty(_this$child$push2, node.tagname, node.child), _defineProperty(_this$child$push2, ":@", node[":@"]), _this$child$push2));
+	      } else {
+	        this.child.push(_defineProperty({}, node.tagname, node.child));
+	      }
+	    }
+	  }]);
+	  return XmlNode;
+	}();
+	var xmlNode$1 = XmlNode;
+
+	var util$1 = util$3;
+
+	//TODO: handle comments
+	function readDocType$1(xmlData, i) {
+	  var entities = {};
+	  if (xmlData[i + 3] === 'O' && xmlData[i + 4] === 'C' && xmlData[i + 5] === 'T' && xmlData[i + 6] === 'Y' && xmlData[i + 7] === 'P' && xmlData[i + 8] === 'E') {
+	    i = i + 9;
+	    var angleBracketsCount = 1;
+	    var hasBody = false,
+	      comment = false;
+	    var exp = "";
+	    for (; i < xmlData.length; i++) {
+	      if (xmlData[i] === '<' && !comment) {
+	        //Determine the tag type
+	        if (hasBody && isEntity(xmlData, i)) {
+	          i += 7;
+	          var _readEntityExp = readEntityExp(xmlData, i + 1);
+	          var _readEntityExp2 = _slicedToArray(_readEntityExp, 3);
+	          entityName = _readEntityExp2[0];
+	          val = _readEntityExp2[1];
+	          i = _readEntityExp2[2];
+	          if (val.indexOf("&") === -1)
+	            //Parameter entities are not supported
+	            entities[validateEntityName(entityName)] = {
+	              regx: RegExp("&".concat(entityName, ";"), "g"),
+	              val: val
+	            };
+	        } else if (hasBody && isElement(xmlData, i)) i += 8; //Not supported
+	        else if (hasBody && isAttlist(xmlData, i)) i += 8; //Not supported
+	        else if (hasBody && isNotation(xmlData, i)) i += 9; //Not supported
+	        else if (isComment) comment = true;else throw new Error("Invalid DOCTYPE");
+	        angleBracketsCount++;
+	        exp = "";
+	      } else if (xmlData[i] === '>') {
+	        //Read tag content
+	        if (comment) {
+	          if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
+	            comment = false;
+	            angleBracketsCount--;
+	          }
+	        } else {
+	          angleBracketsCount--;
+	        }
+	        if (angleBracketsCount === 0) {
+	          break;
+	        }
+	      } else if (xmlData[i] === '[') {
+	        hasBody = true;
+	      } else {
+	        exp += xmlData[i];
+	      }
+	    }
+	    if (angleBracketsCount !== 0) {
+	      throw new Error("Unclosed DOCTYPE");
+	    }
+	  } else {
+	    throw new Error("Invalid Tag instead of DOCTYPE");
+	  }
+	  return {
+	    entities: entities,
+	    i: i
+	  };
+	}
+	function readEntityExp(xmlData, i) {
+	  //External entities are not supported
+	  //    <!ENTITY ext SYSTEM "http://normal-website.com" >
+
+	  //Parameter entities are not supported
+	  //    <!ENTITY entityname "&anotherElement;">
+
+	  //Internal entities are supported
+	  //    <!ENTITY entityname "replacement text">
+
+	  //read EntityName
+	  var entityName = "";
+	  for (; i < xmlData.length && xmlData[i] !== "'" && xmlData[i] !== '"'; i++) {
+	    // if(xmlData[i] === " ") continue;
+	    // else 
+	    entityName += xmlData[i];
+	  }
+	  entityName = entityName.trim();
+	  if (entityName.indexOf(" ") !== -1) throw new Error("External entites are not supported");
+
+	  //read Entity Value
+	  var startChar = xmlData[i++];
+	  var val = "";
+	  for (; i < xmlData.length && xmlData[i] !== startChar; i++) {
+	    val += xmlData[i];
+	  }
+	  return [entityName, val, i];
+	}
+	function isComment(xmlData, i) {
+	  if (xmlData[i + 1] === '!' && xmlData[i + 2] === '-' && xmlData[i + 3] === '-') return true;
+	  return false;
+	}
+	function isEntity(xmlData, i) {
+	  if (xmlData[i + 1] === '!' && xmlData[i + 2] === 'E' && xmlData[i + 3] === 'N' && xmlData[i + 4] === 'T' && xmlData[i + 5] === 'I' && xmlData[i + 6] === 'T' && xmlData[i + 7] === 'Y') return true;
+	  return false;
+	}
+	function isElement(xmlData, i) {
+	  if (xmlData[i + 1] === '!' && xmlData[i + 2] === 'E' && xmlData[i + 3] === 'L' && xmlData[i + 4] === 'E' && xmlData[i + 5] === 'M' && xmlData[i + 6] === 'E' && xmlData[i + 7] === 'N' && xmlData[i + 8] === 'T') return true;
+	  return false;
+	}
+	function isAttlist(xmlData, i) {
+	  if (xmlData[i + 1] === '!' && xmlData[i + 2] === 'A' && xmlData[i + 3] === 'T' && xmlData[i + 4] === 'T' && xmlData[i + 5] === 'L' && xmlData[i + 6] === 'I' && xmlData[i + 7] === 'S' && xmlData[i + 8] === 'T') return true;
+	  return false;
+	}
+	function isNotation(xmlData, i) {
+	  if (xmlData[i + 1] === '!' && xmlData[i + 2] === 'N' && xmlData[i + 3] === 'O' && xmlData[i + 4] === 'T' && xmlData[i + 5] === 'A' && xmlData[i + 6] === 'T' && xmlData[i + 7] === 'I' && xmlData[i + 8] === 'O' && xmlData[i + 9] === 'N') return true;
+	  return false;
+	}
+	function validateEntityName(name) {
+	  if (util$1.isName(name)) return name;else throw new Error("Invalid entity name ".concat(name));
+	}
+	var DocTypeReader = readDocType$1;
+
+	var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
+	var numRegex = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/;
+	// const octRegex = /0x[a-z0-9]+/;
+	// const binRegex = /0x[a-z0-9]+/;
+
+	//polyfill
+	if (!Number.parseInt && window.parseInt) {
+	  Number.parseInt = window.parseInt;
+	}
+	if (!Number.parseFloat && window.parseFloat) {
+	  Number.parseFloat = window.parseFloat;
+	}
+	var consider = {
+	  hex: true,
+	  leadingZeros: true,
+	  decimalPoint: "\.",
+	  eNotation: true
+	  //skipLike: /regex/
+	};
+
+	function toNumber$1(str) {
+	  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	  // const options = Object.assign({}, consider);
+	  // if(opt.leadingZeros === false){
+	  //     options.leadingZeros = false;
+	  // }else if(opt.hex === false){
+	  //     options.hex = false;
+	  // }
+
+	  options = Object.assign({}, consider, options);
+	  if (!str || typeof str !== "string") return str;
+	  var trimmedStr = str.trim();
+	  // if(trimmedStr === "0.0") return 0;
+	  // else if(trimmedStr === "+0.0") return 0;
+	  // else if(trimmedStr === "-0.0") return -0;
+
+	  if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;else if (options.hex && hexRegex.test(trimmedStr)) {
+	    return Number.parseInt(trimmedStr, 16);
+	    // } else if (options.parseOct && octRegex.test(str)) {
+	    //     return Number.parseInt(val, 8);
+	    // }else if (options.parseBin && binRegex.test(str)) {
+	    //     return Number.parseInt(val, 2);
+	  } else {
+	    //separate negative sign, leading zeros, and rest number
+	    var match = numRegex.exec(trimmedStr);
+	    if (match) {
+	      var sign = match[1];
+	      var leadingZeros = match[2];
+	      var numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
+	      //trim ending zeros for floating number
+
+	      var eNotation = match[4] || match[6];
+	      if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str; //-0123
+	      else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str; //0123
+	      else {
+	        //no leading zeros or leading zeros are allowed
+	        var num = Number(trimmedStr);
+	        var numStr = "" + num;
+	        if (numStr.search(/[eE]/) !== -1) {
+	          //given number is long and parsed to eNotation
+	          if (options.eNotation) return num;else return str;
+	        } else if (eNotation) {
+	          //given number has enotation
+	          if (options.eNotation) return num;else return str;
+	        } else if (trimmedStr.indexOf(".") !== -1) {
+	          //floating number
+	          // const decimalPart = match[5].substr(1);
+	          // const intPart = trimmedStr.substr(0,trimmedStr.indexOf("."));
+
+	          // const p = numStr.indexOf(".");
+	          // const givenIntPart = numStr.substr(0,p);
+	          // const givenDecPart = numStr.substr(p+1);
+	          if (numStr === "0" && numTrimmedByZeros === "") return num; //0.0
+	          else if (numStr === numTrimmedByZeros) return num; //0.456. 0.79000
+	          else if (sign && numStr === "-" + numTrimmedByZeros) return num;else return str;
+	        }
+	        if (leadingZeros) {
+	          // if(numTrimmedByZeros === numStr){
+	          //     if(options.leadingZeros) return num;
+	          //     else return str;
+	          // }else return str;
+	          if (numTrimmedByZeros === numStr) return num;else if (sign + numTrimmedByZeros === numStr) return num;else return str;
+	        }
+	        if (trimmedStr === numStr) return num;else if (trimmedStr === sign + numStr) return num;
+	        // else{
+	        //     //number with +/- sign
+	        //     trimmedStr.test(/[-+][0-9]);
+
+	        // }
+	        return str;
+	      }
+	      // else if(!eNotation && trimmedStr && trimmedStr !== Number(trimmedStr) ) return str;
+	    } else {
+	      //non-numeric string
+	      return str;
+	    }
+	  }
+	}
+
+	/**
+	 * 
+	 * @param {string} numStr without leading zeros
+	 * @returns 
+	 */
+	function trimZeros(numStr) {
+	  if (numStr && numStr.indexOf(".") !== -1) {
+	    //float
+	    numStr = numStr.replace(/0+$/, ""); //remove ending zeros
+	    if (numStr === ".") numStr = "0";else if (numStr[0] === ".") numStr = "0" + numStr;else if (numStr[numStr.length - 1] === ".") numStr = numStr.substr(0, numStr.length - 1);
+	    return numStr;
+	  }
+	  return numStr;
+	}
+	var strnum = toNumber$1;
+
+	///@ts-check
+
+	var util = util$3;
+	var xmlNode = xmlNode$1;
+	var readDocType = DocTypeReader;
+	var toNumber = strnum;
+	'<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'.replace(/NAME/g, util.nameRegexp);
+
+	//const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g");
+	//const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g");
+	var OrderedObjParser$1 = /*#__PURE__*/_createClass(function OrderedObjParser(options) {
+	  _classCallCheck(this, OrderedObjParser);
+	  this.options = options;
+	  this.currentNode = null;
+	  this.tagsNodeStack = [];
+	  this.docTypeEntities = {};
+	  this.lastEntities = {
+	    "apos": {
+	      regex: /&(apos|#39|#x27);/g,
+	      val: "'"
+	    },
+	    "gt": {
+	      regex: /&(gt|#62|#x3E);/g,
+	      val: ">"
+	    },
+	    "lt": {
+	      regex: /&(lt|#60|#x3C);/g,
+	      val: "<"
+	    },
+	    "quot": {
+	      regex: /&(quot|#34|#x22);/g,
+	      val: "\""
+	    }
+	  };
+	  this.ampEntity = {
+	    regex: /&(amp|#38|#x26);/g,
+	    val: "&"
+	  };
+	  this.htmlEntities = {
+	    "space": {
+	      regex: /&(nbsp|#160);/g,
+	      val: " "
+	    },
+	    // "lt" : { regex: /&(lt|#60);/g, val: "<" },
+	    // "gt" : { regex: /&(gt|#62);/g, val: ">" },
+	    // "amp" : { regex: /&(amp|#38);/g, val: "&" },
+	    // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
+	    // "apos" : { regex: /&(apos|#39);/g, val: "'" },
+	    "cent": {
+	      regex: /&(cent|#162);/g,
+	      val: "¢"
+	    },
+	    "pound": {
+	      regex: /&(pound|#163);/g,
+	      val: "£"
+	    },
+	    "yen": {
+	      regex: /&(yen|#165);/g,
+	      val: "¥"
+	    },
+	    "euro": {
+	      regex: /&(euro|#8364);/g,
+	      val: "€"
+	    },
+	    "copyright": {
+	      regex: /&(copy|#169);/g,
+	      val: "©"
+	    },
+	    "reg": {
+	      regex: /&(reg|#174);/g,
+	      val: "®"
+	    },
+	    "inr": {
+	      regex: /&(inr|#8377);/g,
+	      val: "₹"
+	    }
+	  };
+	  this.addExternalEntities = addExternalEntities;
+	  this.parseXml = parseXml;
+	  this.parseTextData = parseTextData;
+	  this.resolveNameSpace = resolveNameSpace;
+	  this.buildAttributesMap = buildAttributesMap;
+	  this.isItStopNode = isItStopNode;
+	  this.replaceEntitiesValue = replaceEntitiesValue$1;
+	  this.readStopNodeData = readStopNodeData;
+	  this.saveTextToParentTag = saveTextToParentTag;
+	  this.addChild = addChild;
+	});
+	function addExternalEntities(externalEntities) {
+	  var entKeys = Object.keys(externalEntities);
+	  for (var i = 0; i < entKeys.length; i++) {
+	    var ent = entKeys[i];
+	    this.lastEntities[ent] = {
+	      regex: new RegExp("&" + ent + ";", "g"),
+	      val: externalEntities[ent]
+	    };
+	  }
+	}
+
+	/**
+	 * @param {string} val
+	 * @param {string} tagName
+	 * @param {string} jPath
+	 * @param {boolean} dontTrim
+	 * @param {boolean} hasAttributes
+	 * @param {boolean} isLeafNode
+	 * @param {boolean} escapeEntities
+	 */
+	function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
+	  if (val !== undefined) {
+	    if (this.options.trimValues && !dontTrim) {
+	      val = val.trim();
+	    }
+	    if (val.length > 0) {
+	      if (!escapeEntities) val = this.replaceEntitiesValue(val);
+	      var newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+	      if (newval === null || newval === undefined) {
+	        //don't parse
+	        return val;
+	      } else if (_typeof(newval) !== _typeof(val) || newval !== val) {
+	        //overwrite
+	        return newval;
+	      } else if (this.options.trimValues) {
+	        return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+	      } else {
+	        var trimmedVal = val.trim();
+	        if (trimmedVal === val) {
+	          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+	        } else {
+	          return val;
+	        }
+	      }
+	    }
+	  }
+	}
+	function resolveNameSpace(tagname) {
+	  if (this.options.removeNSPrefix) {
+	    var tags = tagname.split(':');
+	    var prefix = tagname.charAt(0) === '/' ? '/' : '';
+	    if (tags[0] === 'xmlns') {
+	      return '';
+	    }
+	    if (tags.length === 2) {
+	      tagname = prefix + tags[1];
+	    }
+	  }
+	  return tagname;
+	}
+
+	//TODO: change regex to capture NS
+	//const attrsRegx = new RegExp("([\\w\\-\\.\\:]+)\\s*=\\s*(['\"])((.|\n)*?)\\2","gm");
+	var attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
+	function buildAttributesMap(attrStr, jPath, tagName) {
+	  if (!this.options.ignoreAttributes && typeof attrStr === 'string') {
+	    // attrStr = attrStr.replace(/\r?\n/g, ' ');
+	    //attrStr = attrStr || attrStr.trim();
+
+	    var matches = util.getAllMatches(attrStr, attrsRegx);
+	    var len = matches.length; //don't make it inline
+	    var attrs = {};
+	    for (var i = 0; i < len; i++) {
+	      var attrName = this.resolveNameSpace(matches[i][1]);
+	      var oldVal = matches[i][4];
+	      var aName = this.options.attributeNamePrefix + attrName;
+	      if (attrName.length) {
+	        if (this.options.transformAttributeName) {
+	          aName = this.options.transformAttributeName(aName);
+	        }
+	        if (aName === "__proto__") aName = "#__proto__";
+	        if (oldVal !== undefined) {
+	          if (this.options.trimValues) {
+	            oldVal = oldVal.trim();
+	          }
+	          oldVal = this.replaceEntitiesValue(oldVal);
+	          var newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
+	          if (newVal === null || newVal === undefined) {
+	            //don't parse
+	            attrs[aName] = oldVal;
+	          } else if (_typeof(newVal) !== _typeof(oldVal) || newVal !== oldVal) {
+	            //overwrite
+	            attrs[aName] = newVal;
+	          } else {
+	            //parse
+	            attrs[aName] = parseValue(oldVal, this.options.parseAttributeValue, this.options.numberParseOptions);
+	          }
+	        } else if (this.options.allowBooleanAttributes) {
+	          attrs[aName] = true;
+	        }
+	      }
+	    }
+	    if (!Object.keys(attrs).length) {
+	      return;
+	    }
+	    if (this.options.attributesGroupName) {
+	      var attrCollection = {};
+	      attrCollection[this.options.attributesGroupName] = attrs;
+	      return attrCollection;
+	    }
+	    return attrs;
+	  }
+	}
+	var parseXml = function parseXml(xmlData) {
+	  xmlData = xmlData.replace(/\r\n?/g, "\n"); //TODO: remove this line
+	  var xmlObj = new xmlNode('!xml');
+	  var currentNode = xmlObj;
+	  var textData = "";
+	  var jPath = "";
+	  for (var i = 0; i < xmlData.length; i++) {
+	    //for each char in XML data
+	    var ch = xmlData[i];
+	    if (ch === '<') {
+	      // const nextIndex = i+1;
+	      // const _2ndChar = xmlData[nextIndex];
+	      if (xmlData[i + 1] === '/') {
+	        //Closing Tag
+	        var closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
+	        var tagName = xmlData.substring(i + 2, closeIndex).trim();
+	        if (this.options.removeNSPrefix) {
+	          var colonIndex = tagName.indexOf(":");
+	          if (colonIndex !== -1) {
+	            tagName = tagName.substr(colonIndex + 1);
+	          }
+	        }
+	        if (this.options.transformTagName) {
+	          tagName = this.options.transformTagName(tagName);
+	        }
+	        if (currentNode) {
+	          textData = this.saveTextToParentTag(textData, currentNode, jPath);
+	        }
+
+	        //check if last tag of nested tag was unpaired tag
+	        var lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
+	        if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
+	          throw new Error("Unpaired tag can not be used as closing tag: </".concat(tagName, ">"));
+	        }
+	        var propIndex = 0;
+	        if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
+	          propIndex = jPath.lastIndexOf('.', jPath.lastIndexOf('.') - 1);
+	          this.tagsNodeStack.pop();
+	        } else {
+	          propIndex = jPath.lastIndexOf(".");
+	        }
+	        jPath = jPath.substring(0, propIndex);
+	        currentNode = this.tagsNodeStack.pop(); //avoid recursion, set the parent tag scope
+	        textData = "";
+	        i = closeIndex;
+	      } else if (xmlData[i + 1] === '?') {
+	        var tagData = readTagExp(xmlData, i, false, "?>");
+	        if (!tagData) throw new Error("Pi Tag is not closed.");
+	        textData = this.saveTextToParentTag(textData, currentNode, jPath);
+	        if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) ; else {
+	          var childNode = new xmlNode(tagData.tagName);
+	          childNode.add(this.options.textNodeName, "");
+	          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
+	            childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
+	          }
+	          this.addChild(currentNode, childNode, jPath);
+	        }
+	        i = tagData.closeIndex + 1;
+	      } else if (xmlData.substr(i + 1, 3) === '!--') {
+	        var endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
+	        if (this.options.commentPropName) {
+	          var comment = xmlData.substring(i + 4, endIndex - 2);
+	          textData = this.saveTextToParentTag(textData, currentNode, jPath);
+	          currentNode.add(this.options.commentPropName, [_defineProperty({}, this.options.textNodeName, comment)]);
+	        }
+	        i = endIndex;
+	      } else if (xmlData.substr(i + 1, 2) === '!D') {
+	        var result = readDocType(xmlData, i);
+	        this.docTypeEntities = result.entities;
+	        i = result.i;
+	      } else if (xmlData.substr(i + 1, 2) === '![') {
+	        var _closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
+	        var tagExp = xmlData.substring(i + 9, _closeIndex);
+	        textData = this.saveTextToParentTag(textData, currentNode, jPath);
+
+	        //cdata should be set even if it is 0 length string
+	        if (this.options.cdataPropName) {
+	          // let val = this.parseTextData(tagExp, this.options.cdataPropName, jPath + "." + this.options.cdataPropName, true, false, true);
+	          // if(!val) val = "";
+	          currentNode.add(this.options.cdataPropName, [_defineProperty({}, this.options.textNodeName, tagExp)]);
+	        } else {
+	          var val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
+	          if (val == undefined) val = "";
+	          currentNode.add(this.options.textNodeName, val);
+	        }
+	        i = _closeIndex + 2;
+	      } else {
+	        //Opening tag
+	        var _result = readTagExp(xmlData, i, this.options.removeNSPrefix);
+	        var _tagName = _result.tagName;
+	        var _tagExp = _result.tagExp;
+	        var attrExpPresent = _result.attrExpPresent;
+	        var _closeIndex2 = _result.closeIndex;
+	        if (this.options.transformTagName) {
+	          _tagName = this.options.transformTagName(_tagName);
+	        }
+
+	        //save text as child node
+	        if (currentNode && textData) {
+	          if (currentNode.tagname !== '!xml') {
+	            //when nested tag is found
+	            textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
+	          }
+	        }
+
+	        //check if last tag was unpaired tag
+	        var lastTag = currentNode;
+	        if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
+	          currentNode = this.tagsNodeStack.pop();
+	          jPath = jPath.substring(0, jPath.lastIndexOf("."));
+	        }
+	        if (_tagName !== xmlObj.tagname) {
+	          jPath += jPath ? "." + _tagName : _tagName;
+	        }
+	        if (this.isItStopNode(this.options.stopNodes, jPath, _tagName)) {
+	          //TODO: namespace
+	          var tagContent = "";
+	          //self-closing tag
+	          if (_tagExp.length > 0 && _tagExp.lastIndexOf("/") === _tagExp.length - 1) {
+	            i = _result.closeIndex;
+	          }
+	          //unpaired tag
+	          else if (this.options.unpairedTags.indexOf(_tagName) !== -1) {
+	            i = _result.closeIndex;
+	          }
+	          //normal tag
+	          else {
+	            //read until closing tag is found
+	            var _result2 = this.readStopNodeData(xmlData, _tagName, _closeIndex2 + 1);
+	            if (!_result2) throw new Error("Unexpected end of ".concat(_tagName));
+	            i = _result2.i;
+	            tagContent = _result2.tagContent;
+	          }
+	          var _childNode = new xmlNode(_tagName);
+	          if (_tagName !== _tagExp && attrExpPresent) {
+	            _childNode[":@"] = this.buildAttributesMap(_tagExp, jPath, _tagName);
+	          }
+	          if (tagContent) {
+	            tagContent = this.parseTextData(tagContent, _tagName, jPath, true, attrExpPresent, true, true);
+	          }
+	          jPath = jPath.substr(0, jPath.lastIndexOf("."));
+	          _childNode.add(this.options.textNodeName, tagContent);
+	          this.addChild(currentNode, _childNode, jPath);
+	        } else {
+	          //selfClosing tag
+	          if (_tagExp.length > 0 && _tagExp.lastIndexOf("/") === _tagExp.length - 1) {
+	            if (_tagName[_tagName.length - 1] === "/") {
+	              //remove trailing '/'
+	              _tagName = _tagName.substr(0, _tagName.length - 1);
+	              jPath = jPath.substr(0, jPath.length - 1);
+	              _tagExp = _tagName;
+	            } else {
+	              _tagExp = _tagExp.substr(0, _tagExp.length - 1);
+	            }
+	            if (this.options.transformTagName) {
+	              _tagName = this.options.transformTagName(_tagName);
+	            }
+	            var _childNode2 = new xmlNode(_tagName);
+	            if (_tagName !== _tagExp && attrExpPresent) {
+	              _childNode2[":@"] = this.buildAttributesMap(_tagExp, jPath, _tagName);
+	            }
+	            this.addChild(currentNode, _childNode2, jPath);
+	            jPath = jPath.substr(0, jPath.lastIndexOf("."));
+	          }
+	          //opening tag
+	          else {
+	            var _childNode3 = new xmlNode(_tagName);
+	            this.tagsNodeStack.push(currentNode);
+	            if (_tagName !== _tagExp && attrExpPresent) {
+	              _childNode3[":@"] = this.buildAttributesMap(_tagExp, jPath, _tagName);
+	            }
+	            this.addChild(currentNode, _childNode3, jPath);
+	            currentNode = _childNode3;
+	          }
+	          textData = "";
+	          i = _closeIndex2;
+	        }
+	      }
+	    } else {
+	      textData += xmlData[i];
+	    }
+	  }
+	  return xmlObj.child;
+	};
+	function addChild(currentNode, childNode, jPath) {
+	  var result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
+	  if (result === false) ; else if (typeof result === "string") {
+	    childNode.tagname = result;
+	    currentNode.addChild(childNode);
+	  } else {
+	    currentNode.addChild(childNode);
+	  }
+	}
+	var replaceEntitiesValue$1 = function replaceEntitiesValue(val) {
+	  if (this.options.processEntities) {
+	    for (var entityName in this.docTypeEntities) {
+	      var entity = this.docTypeEntities[entityName];
+	      val = val.replace(entity.regx, entity.val);
+	    }
+	    for (var _entityName in this.lastEntities) {
+	      var _entity = this.lastEntities[_entityName];
+	      val = val.replace(_entity.regex, _entity.val);
+	    }
+	    if (this.options.htmlEntities) {
+	      for (var _entityName2 in this.htmlEntities) {
+	        var _entity2 = this.htmlEntities[_entityName2];
+	        val = val.replace(_entity2.regex, _entity2.val);
+	      }
+	    }
+	    val = val.replace(this.ampEntity.regex, this.ampEntity.val);
+	  }
+	  return val;
+	};
+	function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
+	  if (textData) {
+	    //store previously collected data as textNode
+	    if (isLeafNode === undefined) isLeafNode = Object.keys(currentNode.child).length === 0;
+	    textData = this.parseTextData(textData, currentNode.tagname, jPath, false, currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false, isLeafNode);
+	    if (textData !== undefined && textData !== "") currentNode.add(this.options.textNodeName, textData);
+	    textData = "";
+	  }
+	  return textData;
+	}
+
+	//TODO: use jPath to simplify the logic
+	/**
+	 * 
+	 * @param {string[]} stopNodes 
+	 * @param {string} jPath
+	 * @param {string} currentTagName 
+	 */
+	function isItStopNode(stopNodes, jPath, currentTagName) {
+	  var allNodesExp = "*." + currentTagName;
+	  for (var stopNodePath in stopNodes) {
+	    var stopNodeExp = stopNodes[stopNodePath];
+	    if (allNodesExp === stopNodeExp || jPath === stopNodeExp) return true;
+	  }
+	  return false;
+	}
+
+	/**
+	 * Returns the tag Expression and where it is ending handling single-double quotes situation
+	 * @param {string} xmlData 
+	 * @param {number} i starting index
+	 * @returns 
+	 */
+	function tagExpWithClosingIndex(xmlData, i) {
+	  var closingChar = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ">";
+	  var attrBoundary;
+	  var tagExp = "";
+	  for (var index = i; index < xmlData.length; index++) {
+	    var ch = xmlData[index];
+	    if (attrBoundary) {
+	      if (ch === attrBoundary) attrBoundary = ""; //reset
+	    } else if (ch === '"' || ch === "'") {
+	      attrBoundary = ch;
+	    } else if (ch === closingChar[0]) {
+	      if (closingChar[1]) {
+	        if (xmlData[index + 1] === closingChar[1]) {
+	          return {
+	            data: tagExp,
+	            index: index
+	          };
+	        }
+	      } else {
+	        return {
+	          data: tagExp,
+	          index: index
+	        };
+	      }
+	    } else if (ch === '\t') {
+	      ch = " ";
+	    }
+	    tagExp += ch;
+	  }
+	}
+	function findClosingIndex(xmlData, str, i, errMsg) {
+	  var closingIndex = xmlData.indexOf(str, i);
+	  if (closingIndex === -1) {
+	    throw new Error(errMsg);
+	  } else {
+	    return closingIndex + str.length - 1;
+	  }
+	}
+	function readTagExp(xmlData, i, removeNSPrefix) {
+	  var closingChar = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ">";
+	  var result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
+	  if (!result) return;
+	  var tagExp = result.data;
+	  var closeIndex = result.index;
+	  var separatorIndex = tagExp.search(/\s/);
+	  var tagName = tagExp;
+	  var attrExpPresent = true;
+	  if (separatorIndex !== -1) {
+	    //separate tag name and attributes expression
+	    tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
+	    tagExp = tagExp.substr(separatorIndex + 1);
+	  }
+	  if (removeNSPrefix) {
+	    var colonIndex = tagName.indexOf(":");
+	    if (colonIndex !== -1) {
+	      tagName = tagName.substr(colonIndex + 1);
+	      attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
+	    }
+	  }
+	  return {
+	    tagName: tagName,
+	    tagExp: tagExp,
+	    closeIndex: closeIndex,
+	    attrExpPresent: attrExpPresent
+	  };
+	}
+	/**
+	 * find paired tag for a stop node
+	 * @param {string} xmlData 
+	 * @param {string} tagName 
+	 * @param {number} i 
+	 */
+	function readStopNodeData(xmlData, tagName, i) {
+	  var startIndex = i;
+	  // Starting at 1 since we already have an open tag
+	  var openTagCount = 1;
+	  for (; i < xmlData.length; i++) {
+	    if (xmlData[i] === "<") {
+	      if (xmlData[i + 1] === "/") {
+	        //close tag
+	        var closeIndex = findClosingIndex(xmlData, ">", i, "".concat(tagName, " is not closed"));
+	        var closeTagName = xmlData.substring(i + 2, closeIndex).trim();
+	        if (closeTagName === tagName) {
+	          openTagCount--;
+	          if (openTagCount === 0) {
+	            return {
+	              tagContent: xmlData.substring(startIndex, i),
+	              i: closeIndex
+	            };
+	          }
+	        }
+	        i = closeIndex;
+	      } else if (xmlData[i + 1] === '?') {
+	        var _closeIndex3 = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
+	        i = _closeIndex3;
+	      } else if (xmlData.substr(i + 1, 3) === '!--') {
+	        var _closeIndex4 = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
+	        i = _closeIndex4;
+	      } else if (xmlData.substr(i + 1, 2) === '![') {
+	        var _closeIndex5 = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
+	        i = _closeIndex5;
+	      } else {
+	        var tagData = readTagExp(xmlData, i, '>');
+	        if (tagData) {
+	          var openTagName = tagData && tagData.tagName;
+	          if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") {
+	            openTagCount++;
+	          }
+	          i = tagData.closeIndex;
+	        }
+	      }
+	    }
+	  } //end for loop
+	}
+
+	function parseValue(val, shouldParse, options) {
+	  if (shouldParse && typeof val === 'string') {
+	    //console.log(options)
+	    var newval = val.trim();
+	    if (newval === 'true') return true;else if (newval === 'false') return false;else return toNumber(val, options);
+	  } else {
+	    if (util.isExist(val)) {
+	      return val;
+	    } else {
+	      return '';
+	    }
+	  }
+	}
+	var OrderedObjParser_1 = OrderedObjParser$1;
+
+	var node2json = {};
+
+	/**
+	 * 
+	 * @param {array} node 
+	 * @param {any} options 
+	 * @returns 
+	 */
+	function prettify$1(node, options) {
+	  return compress(node, options);
+	}
+
+	/**
+	 * 
+	 * @param {array} arr 
+	 * @param {object} options 
+	 * @param {string} jPath 
+	 * @returns object
+	 */
+	function compress(arr, options, jPath) {
+	  var text;
+	  var compressedObj = {};
+	  for (var i = 0; i < arr.length; i++) {
+	    var tagObj = arr[i];
+	    var property = propName$1(tagObj);
+	    var newJpath = "";
+	    if (jPath === undefined) newJpath = property;else newJpath = jPath + "." + property;
+	    if (property === options.textNodeName) {
+	      if (text === undefined) text = tagObj[property];else text += "" + tagObj[property];
+	    } else if (property === undefined) {
+	      continue;
+	    } else if (tagObj[property]) {
+	      var val = compress(tagObj[property], options, newJpath);
+	      var isLeaf = isLeafTag(val, options);
+	      if (tagObj[":@"]) {
+	        assignAttributes(val, tagObj[":@"], newJpath, options);
+	      } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {
+	        val = val[options.textNodeName];
+	      } else if (Object.keys(val).length === 0) {
+	        if (options.alwaysCreateTextNode) val[options.textNodeName] = "";else val = "";
+	      }
+	      if (compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
+	        if (!Array.isArray(compressedObj[property])) {
+	          compressedObj[property] = [compressedObj[property]];
+	        }
+	        compressedObj[property].push(val);
+	      } else {
+	        //TODO: if a node is not an array, then check if it should be an array
+	        //also determine if it is a leaf node
+	        if (options.isArray(property, newJpath, isLeaf)) {
+	          compressedObj[property] = [val];
+	        } else {
+	          compressedObj[property] = val;
+	        }
+	      }
+	    }
+	  }
+	  // if(text && text.length > 0) compressedObj[options.textNodeName] = text;
+	  if (typeof text === "string") {
+	    if (text.length > 0) compressedObj[options.textNodeName] = text;
+	  } else if (text !== undefined) compressedObj[options.textNodeName] = text;
+	  return compressedObj;
+	}
+	function propName$1(obj) {
+	  var keys = Object.keys(obj);
+	  for (var i = 0; i < keys.length; i++) {
+	    var key = keys[i];
+	    if (key !== ":@") return key;
+	  }
+	}
+	function assignAttributes(obj, attrMap, jpath, options) {
+	  if (attrMap) {
+	    var keys = Object.keys(attrMap);
+	    var len = keys.length; //don't make it inline
+	    for (var i = 0; i < len; i++) {
+	      var atrrName = keys[i];
+	      if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+	        obj[atrrName] = [attrMap[atrrName]];
+	      } else {
+	        obj[atrrName] = attrMap[atrrName];
+	      }
+	    }
+	  }
+	}
+	function isLeafTag(obj, options) {
+	  var textNodeName = options.textNodeName;
+	  var propCount = Object.keys(obj).length;
+	  if (propCount === 0) {
+	    return true;
+	  }
+	  if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) {
+	    return true;
+	  }
+	  return false;
+	}
+	node2json.prettify = prettify$1;
+
+	var buildOptions = OptionsBuilder.buildOptions;
+	var OrderedObjParser = OrderedObjParser_1;
+	var prettify = node2json.prettify;
+	var validator$1 = validator$2;
+	var XMLParser$1 = /*#__PURE__*/function () {
+	  function XMLParser(options) {
+	    _classCallCheck(this, XMLParser);
+	    this.externalEntities = {};
+	    this.options = buildOptions(options);
+	  }
+	  /**
+	   * Parse XML dats to JS object 
+	   * @param {string|Buffer} xmlData 
+	   * @param {boolean|Object} validationOption 
+	   */
+	  _createClass(XMLParser, [{
+	    key: "parse",
+	    value: function parse(xmlData, validationOption) {
+	      if (typeof xmlData === "string") ; else if (xmlData.toString) {
+	        xmlData = xmlData.toString();
+	      } else {
+	        throw new Error("XML data is accepted in String or Bytes[] form.");
+	      }
+	      if (validationOption) {
+	        if (validationOption === true) validationOption = {}; //validate with default options
+
+	        var result = validator$1.validate(xmlData, validationOption);
+	        if (result !== true) {
+	          throw Error("".concat(result.err.msg, ":").concat(result.err.line, ":").concat(result.err.col));
+	        }
+	      }
+	      var orderedObjParser = new OrderedObjParser(this.options);
+	      orderedObjParser.addExternalEntities(this.externalEntities);
+	      var orderedResult = orderedObjParser.parseXml(xmlData);
+	      if (this.options.preserveOrder || orderedResult === undefined) return orderedResult;else return prettify(orderedResult, this.options);
+	    }
+
+	    /**
+	     * Add Entity which is not by default supported by this library
+	     * @param {string} key 
+	     * @param {string} value 
+	     */
+	  }, {
+	    key: "addEntity",
+	    value: function addEntity(key, value) {
+	      if (value.indexOf("&") !== -1) {
+	        throw new Error("Entity value can't have '&'");
+	      } else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) {
+	        throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
+	      } else if (value === "&") {
+	        throw new Error("An entity with value '&' is not permitted");
+	      } else {
+	        this.externalEntities[key] = value;
+	      }
+	    }
+	  }]);
+	  return XMLParser;
+	}();
+	var XMLParser_1 = XMLParser$1;
+
+	var EOL = "\n";
+
+	/**
+	 * 
+	 * @param {array} jArray 
+	 * @param {any} options 
+	 * @returns 
+	 */
+	function toXml(jArray, options) {
+	  var indentation = "";
+	  if (options.format && options.indentBy.length > 0) {
+	    indentation = EOL;
+	  }
+	  return arrToStr(jArray, options, "", indentation);
+	}
+	function arrToStr(arr, options, jPath, indentation) {
+	  var xmlStr = "";
+	  var isPreviousElementTag = false;
+	  for (var i = 0; i < arr.length; i++) {
+	    var tagObj = arr[i];
+	    var tagName = propName(tagObj);
+	    var newJPath = "";
+	    if (jPath.length === 0) newJPath = tagName;else newJPath = "".concat(jPath, ".").concat(tagName);
+	    if (tagName === options.textNodeName) {
+	      var tagText = tagObj[tagName];
+	      if (!isStopNode(newJPath, options)) {
+	        tagText = options.tagValueProcessor(tagName, tagText);
+	        tagText = replaceEntitiesValue(tagText, options);
+	      }
+	      if (isPreviousElementTag) {
+	        xmlStr += indentation;
+	      }
+	      xmlStr += tagText;
+	      isPreviousElementTag = false;
+	      continue;
+	    } else if (tagName === options.cdataPropName) {
+	      if (isPreviousElementTag) {
+	        xmlStr += indentation;
+	      }
+	      xmlStr += "<![CDATA[".concat(tagObj[tagName][0][options.textNodeName], "]]>");
+	      isPreviousElementTag = false;
+	      continue;
+	    } else if (tagName === options.commentPropName) {
+	      xmlStr += indentation + "<!--".concat(tagObj[tagName][0][options.textNodeName], "-->");
+	      isPreviousElementTag = true;
+	      continue;
+	    } else if (tagName[0] === "?") {
+	      var _attStr = attr_to_str(tagObj[":@"], options);
+	      var tempInd = tagName === "?xml" ? "" : indentation;
+	      var piTextNodeName = tagObj[tagName][0][options.textNodeName];
+	      piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : ""; //remove extra spacing
+	      xmlStr += tempInd + "<".concat(tagName).concat(piTextNodeName).concat(_attStr, "?>");
+	      isPreviousElementTag = true;
+	      continue;
+	    }
+	    var newIdentation = indentation;
+	    if (newIdentation !== "") {
+	      newIdentation += options.indentBy;
+	    }
+	    var attStr = attr_to_str(tagObj[":@"], options);
+	    var tagStart = indentation + "<".concat(tagName).concat(attStr);
+	    var tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
+	    if (options.unpairedTags.indexOf(tagName) !== -1) {
+	      if (options.suppressUnpairedNode) xmlStr += tagStart + ">";else xmlStr += tagStart + "/>";
+	    } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {
+	      xmlStr += tagStart + "/>";
+	    } else if (tagValue && tagValue.endsWith(">")) {
+	      xmlStr += tagStart + ">".concat(tagValue).concat(indentation, "</").concat(tagName, ">");
+	    } else {
+	      xmlStr += tagStart + ">";
+	      if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) {
+	        xmlStr += indentation + options.indentBy + tagValue + indentation;
+	      } else {
+	        xmlStr += tagValue;
+	      }
+	      xmlStr += "</".concat(tagName, ">");
+	    }
+	    isPreviousElementTag = true;
+	  }
+	  return xmlStr;
+	}
+	function propName(obj) {
+	  var keys = Object.keys(obj);
+	  for (var i = 0; i < keys.length; i++) {
+	    var key = keys[i];
+	    if (key !== ":@") return key;
+	  }
+	}
+	function attr_to_str(attrMap, options) {
+	  var attrStr = "";
+	  if (attrMap && !options.ignoreAttributes) {
+	    for (var attr in attrMap) {
+	      var attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
+	      attrVal = replaceEntitiesValue(attrVal, options);
+	      if (attrVal === true && options.suppressBooleanAttributes) {
+	        attrStr += " ".concat(attr.substr(options.attributeNamePrefix.length));
+	      } else {
+	        attrStr += " ".concat(attr.substr(options.attributeNamePrefix.length), "=\"").concat(attrVal, "\"");
+	      }
+	    }
+	  }
+	  return attrStr;
+	}
+	function isStopNode(jPath, options) {
+	  jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
+	  var tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
+	  for (var index in options.stopNodes) {
+	    if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName) return true;
+	  }
+	  return false;
+	}
+	function replaceEntitiesValue(textValue, options) {
+	  if (textValue && textValue.length > 0 && options.processEntities) {
+	    for (var i = 0; i < options.entities.length; i++) {
+	      var entity = options.entities[i];
+	      textValue = textValue.replace(entity.regex, entity.val);
+	    }
+	  }
+	  return textValue;
+	}
+	var orderedJs2Xml = toXml;
+
+	//parse Empty Node as self closing node
+	var buildFromOrderedJs = orderedJs2Xml;
+	var defaultOptions = {
+	  attributeNamePrefix: '@_',
+	  attributesGroupName: false,
+	  textNodeName: '#text',
+	  ignoreAttributes: true,
+	  cdataPropName: false,
+	  format: false,
+	  indentBy: '  ',
+	  suppressEmptyNode: false,
+	  suppressUnpairedNode: true,
+	  suppressBooleanAttributes: true,
+	  tagValueProcessor: function tagValueProcessor(key, a) {
+	    return a;
+	  },
+	  attributeValueProcessor: function attributeValueProcessor(attrName, a) {
+	    return a;
+	  },
+	  preserveOrder: false,
+	  commentPropName: false,
+	  unpairedTags: [],
+	  entities: [{
+	    regex: new RegExp("&", "g"),
+	    val: "&amp;"
+	  },
+	  //it must be on top
+	  {
+	    regex: new RegExp(">", "g"),
+	    val: "&gt;"
+	  }, {
+	    regex: new RegExp("<", "g"),
+	    val: "&lt;"
+	  }, {
+	    regex: new RegExp("\'", "g"),
+	    val: "&apos;"
+	  }, {
+	    regex: new RegExp("\"", "g"),
+	    val: "&quot;"
+	  }],
+	  processEntities: true,
+	  stopNodes: [],
+	  // transformTagName: false,
+	  // transformAttributeName: false,
+	  oneListGroup: false
+	};
+	function Builder(options) {
+	  this.options = Object.assign({}, defaultOptions, options);
+	  if (this.options.ignoreAttributes || this.options.attributesGroupName) {
+	    this.isAttribute = function /*a*/
+	    () {
+	      return false;
+	    };
+	  } else {
+	    this.attrPrefixLen = this.options.attributeNamePrefix.length;
+	    this.isAttribute = isAttribute;
+	  }
+	  this.processTextOrObjNode = processTextOrObjNode;
+	  if (this.options.format) {
+	    this.indentate = indentate;
+	    this.tagEndChar = '>\n';
+	    this.newLine = '\n';
+	  } else {
+	    this.indentate = function () {
+	      return '';
+	    };
+	    this.tagEndChar = '>';
+	    this.newLine = '';
+	  }
+	}
+	Builder.prototype.build = function (jObj) {
+	  if (this.options.preserveOrder) {
+	    return buildFromOrderedJs(jObj, this.options);
+	  } else {
+	    if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
+	      jObj = _defineProperty({}, this.options.arrayNodeName, jObj);
+	    }
+	    return this.j2x(jObj, 0).val;
+	  }
+	};
+	Builder.prototype.j2x = function (jObj, level) {
+	  var attrStr = '';
+	  var val = '';
+	  for (var key in jObj) {
+	    if (typeof jObj[key] === 'undefined') {
+	      // supress undefined node only if it is not an attribute
+	      if (this.isAttribute(key)) {
+	        val += '';
+	      }
+	    } else if (jObj[key] === null) {
+	      // null attribute should be ignored by the attribute list, but should not cause the tag closing
+	      if (this.isAttribute(key)) {
+	        val += '';
+	      } else if (key[0] === '?') {
+	        val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
+	      } else {
+	        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+	      }
+	      // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+	    } else if (jObj[key] instanceof Date) {
+	      val += this.buildTextValNode(jObj[key], key, '', level);
+	    } else if (_typeof(jObj[key]) !== 'object') {
+	      //premitive type
+	      var attr = this.isAttribute(key);
+	      if (attr) {
+	        attrStr += this.buildAttrPairStr(attr, '' + jObj[key]);
+	      } else {
+	        //tag value
+	        if (key === this.options.textNodeName) {
+	          var newval = this.options.tagValueProcessor(key, '' + jObj[key]);
+	          val += this.replaceEntitiesValue(newval);
+	        } else {
+	          val += this.buildTextValNode(jObj[key], key, '', level);
+	        }
+	      }
+	    } else if (Array.isArray(jObj[key])) {
+	      //repeated nodes
+	      var arrLen = jObj[key].length;
+	      var listTagVal = "";
+	      for (var j = 0; j < arrLen; j++) {
+	        var item = jObj[key][j];
+	        if (typeof item === 'undefined') ; else if (item === null) {
+	          if (key[0] === "?") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+	          // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+	        } else if (_typeof(item) === 'object') {
+	          if (this.options.oneListGroup) {
+	            listTagVal += this.j2x(item, level + 1).val;
+	          } else {
+	            listTagVal += this.processTextOrObjNode(item, key, level);
+	          }
+	        } else {
+	          listTagVal += this.buildTextValNode(item, key, '', level);
+	        }
+	      }
+	      if (this.options.oneListGroup) {
+	        listTagVal = this.buildObjectNode(listTagVal, key, '', level);
+	      }
+	      val += listTagVal;
+	    } else {
+	      //nested node
+	      if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
+	        var Ks = Object.keys(jObj[key]);
+	        var L = Ks.length;
+	        for (var _j = 0; _j < L; _j++) {
+	          attrStr += this.buildAttrPairStr(Ks[_j], '' + jObj[key][Ks[_j]]);
+	        }
+	      } else {
+	        val += this.processTextOrObjNode(jObj[key], key, level);
+	      }
+	    }
+	  }
+	  return {
+	    attrStr: attrStr,
+	    val: val
+	  };
+	};
+	Builder.prototype.buildAttrPairStr = function (attrName, val) {
+	  val = this.options.attributeValueProcessor(attrName, '' + val);
+	  val = this.replaceEntitiesValue(val);
+	  if (this.options.suppressBooleanAttributes && val === "true") {
+	    return ' ' + attrName;
+	  } else return ' ' + attrName + '="' + val + '"';
+	};
+	function processTextOrObjNode(object, key, level) {
+	  var result = this.j2x(object, level + 1);
+	  if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {
+	    return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
+	  } else {
+	    return this.buildObjectNode(result.val, key, result.attrStr, level);
+	  }
+	}
+	Builder.prototype.buildObjectNode = function (val, key, attrStr, level) {
+	  if (val === "") {
+	    if (key[0] === "?") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;else {
+	      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
+	    }
+	  } else {
+	    var tagEndExp = '</' + key + this.tagEndChar;
+	    var piClosingChar = "";
+	    if (key[0] === "?") {
+	      piClosingChar = "?";
+	      tagEndExp = "";
+	    }
+
+	    // attrStr is an empty string in case the attribute came as undefined or null
+	    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {
+	      return this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp;
+	    } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
+	      return this.indentate(level) + "<!--".concat(val, "-->") + this.newLine;
+	    } else {
+	      return this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
+	    }
+	  }
+	};
+	Builder.prototype.closeTag = function (key) {
+	  var closeTag = "";
+	  if (this.options.unpairedTags.indexOf(key) !== -1) {
+	    //unpaired
+	    if (!this.options.suppressUnpairedNode) closeTag = "/";
+	  } else if (this.options.suppressEmptyNode) {
+	    //empty
+	    closeTag = "/";
+	  } else {
+	    closeTag = "></".concat(key);
+	  }
+	  return closeTag;
+	};
+
+	Builder.prototype.buildTextValNode = function (val, key, attrStr, level) {
+	  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
+	    return this.indentate(level) + "<![CDATA[".concat(val, "]]>") + this.newLine;
+	  } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
+	    return this.indentate(level) + "<!--".concat(val, "-->") + this.newLine;
+	  } else if (key[0] === "?") {
+	    //PI tag
+	    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;
+	  } else {
+	    var textValue = this.options.tagValueProcessor(key, val);
+	    textValue = this.replaceEntitiesValue(textValue);
+	    if (textValue === '') {
+	      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
+	    } else {
+	      return this.indentate(level) + '<' + key + attrStr + '>' + textValue + '</' + key + this.tagEndChar;
+	    }
+	  }
+	};
+	Builder.prototype.replaceEntitiesValue = function (textValue) {
+	  if (textValue && textValue.length > 0 && this.options.processEntities) {
+	    for (var i = 0; i < this.options.entities.length; i++) {
+	      var entity = this.options.entities[i];
+	      textValue = textValue.replace(entity.regex, entity.val);
+	    }
+	  }
+	  return textValue;
+	};
+	function indentate(level) {
+	  return this.options.indentBy.repeat(level);
+	}
+	function isAttribute(name /*, options*/) {
+	  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {
+	    return name.substr(this.attrPrefixLen);
+	  } else {
+	    return false;
+	  }
+	}
+	var json2xml = Builder;
+
+	var validator = validator$2;
+	var XMLParser = XMLParser_1;
+	var XMLBuilder = json2xml;
+	var fxp = {
+	  XMLParser: XMLParser,
+	  XMLValidator: validator,
+	  XMLBuilder: XMLBuilder
+	};
+
 	const SYMBOL_UPDATE_TAG_KEY = ['symbolType', 'size', ...GRAPHIC_UPDATE_TAG_KEY];
 	let Symbol$1 = class Symbol extends Graphic {
 	    constructor(params = { symbolType: 'circle' }) {
@@ -20725,6 +23072,43 @@
 	            this._parsedPath = path;
 	            return path;
 	        }
+	        const isSvg = fxp.XMLValidator.validate(symbolType, {
+	            allowBooleanAttributes: true
+	        });
+	        if (isSvg === true) {
+	            const parser = new fxp.XMLParser({ ignoreAttributes: false });
+	            const { svg } = parser.parse(symbolType);
+	            if (!svg) {
+	                return null;
+	            }
+	            const path = isArray(svg.path) ? svg.path : [svg.path];
+	            const b = new AABBBounds();
+	            const cacheList = [];
+	            path.forEach((item) => {
+	                const cache = new CustomPath2D().fromString(item['@_d']);
+	                const attribute = {
+	                    fill: 'black'
+	                };
+	                SVG_PARSE_ATTRIBUTE_MAP_KEYS.forEach(k => {
+	                    if (item[k]) {
+	                        attribute[SVG_PARSE_ATTRIBUTE_MAP[k]] = item[k];
+	                    }
+	                });
+	                cacheList.push({
+	                    path: cache,
+	                    attribute
+	                });
+	                b.union(cache.bounds);
+	            });
+	            const width = b.width();
+	            const height = b.height();
+	            const maxWH = max(width, height);
+	            const scale = 1 / maxWH;
+	            cacheList.forEach(cache => cache.path.transform(0, 0, scale, scale));
+	            this._parsedPath = new CustomSymbolClass(symbolType, cacheList, true);
+	            Symbol.userSymbolMap[symbolType] = this._parsedPath;
+	            return this._parsedPath;
+	        }
 	        const cache = new CustomPath2D().fromString(symbolType);
 	        const width = cache.bounds.width();
 	        const height = cache.bounds.height();
@@ -20784,7 +23168,7 @@
 	            : new CustomPath2D().fromString(symbolInstance.pathStr, x, y, formattedSize[0], formattedSize[1]);
 	    }
 	    clone() {
-	        return new Symbol(Object.assign({}, this.attribute));
+	        return new Symbol({ ...this.attribute });
 	    }
 	};
 	Symbol$1.userSymbolMap = {};
@@ -20890,7 +23274,7 @@
 	        return path;
 	    }
 	    clone() {
-	        return new Line(Object.assign({}, this.attribute));
+	        return new Line({ ...this.attribute });
 	    }
 	};
 
@@ -20958,7 +23342,7 @@
 	        return path;
 	    }
 	    clone() {
-	        return new Rect(Object.assign({}, this.attribute));
+	        return new Rect({ ...this.attribute });
 	    }
 	}
 
@@ -21170,7 +23554,7 @@
 	        this.currentStates = [];
 	    }
 	    clone() {
-	        const glyph = new Glyph(Object.assign({}, this.attribute));
+	        const glyph = new Glyph({ ...this.attribute });
 	        glyph.setSubGraphic(this.subGraphic.map(g => g.clone()));
 	        return glyph;
 	    }
@@ -21724,7 +24108,7 @@
 	        return false;
 	    }
 	    clone() {
-	        return new Image(Object.assign({}, this.attribute));
+	        return new Image({ ...this.attribute });
 	    }
 	}
 
@@ -22282,7 +24666,7 @@
 	        this._frameCache = frame;
 	    }
 	    clone() {
-	        return new RichText(Object.assign({}, this.attribute));
+	        return new RichText({ ...this.attribute });
 	    }
 	    setStage(stage, layer) {
 	        super.setStage(stage, layer);
@@ -22426,7 +24810,7 @@
 	        return new CustomPath2D().fromCustomPath2D(this.getParsedPathShape(), x, y);
 	    }
 	    clone() {
-	        return new Path(Object.assign({}, this.attribute));
+	        return new Path({ ...this.attribute });
 	    }
 	}
 
@@ -22540,7 +24924,7 @@
 	        return path;
 	    }
 	    clone() {
-	        return new Area(Object.assign({}, this.attribute));
+	        return new Area({ ...this.attribute });
 	    }
 	}
 
@@ -22742,7 +25126,7 @@
 	        return path;
 	    }
 	    clone() {
-	        return new Arc(Object.assign({}, this.attribute));
+	        return new Arc({ ...this.attribute });
 	    }
 	}
 
@@ -22839,7 +25223,7 @@
 	        return path;
 	    }
 	    clone() {
-	        return new Polygon(Object.assign({}, this.attribute));
+	        return new Polygon({ ...this.attribute });
 	    }
 	}
 
@@ -25762,13 +28146,51 @@
 	            const p = context.project(x, y, z);
 	            const camera = context.camera;
 	            context.camera = null;
-	            if (parsedPath.draw(context, size, p.x, p.y) === false) {
+	            if (parsedPath.draw(context, size, p.x, p.y, undefined, (p, a) => {
+	                if (a.fill) {
+	                    if (fillCb) {
+	                        fillCb(context, symbol.attribute, symbolAttribute);
+	                    }
+	                    else {
+	                        context.setCommonStyle(symbol, a, originX - x, originY - y);
+	                        context.fill();
+	                    }
+	                }
+	                if (a.stroke) {
+	                    if (strokeCb) {
+	                        strokeCb(context, symbol.attribute, symbolAttribute);
+	                    }
+	                    else {
+	                        context.setStrokeStyle(symbol, a, (originX - x) / scaleX, (originY - y) / scaleY);
+	                        context.stroke();
+	                    }
+	                }
+	            }) === false) {
 	                context.closePath();
 	            }
 	            context.camera = camera;
 	        }
 	        else {
-	            if (parsedPath.draw(context, size, x, y, z) === false) {
+	            if (parsedPath.draw(context, size, x, y, z, (p, a) => {
+	                if (a.fill) {
+	                    if (fillCb) {
+	                        fillCb(context, symbol.attribute, symbolAttribute);
+	                    }
+	                    else {
+	                        context.setCommonStyle(symbol, a, originX - x, originY - y);
+	                        context.fill();
+	                    }
+	                }
+	                if (a.stroke) {
+	                    if (strokeCb) {
+	                        strokeCb(context, symbol.attribute, symbolAttribute);
+	                    }
+	                    else {
+	                        context.setStrokeStyle(symbol, a, (originX - x) / scaleX, (originY - y) / scaleY);
+	                        context.stroke();
+	                    }
+	                }
+	            }) === false) {
 	                context.closePath();
 	            }
 	        }
@@ -25782,7 +28204,7 @@
 	            }
 	        });
 	        context.setShadowStyle && context.setShadowStyle(symbol, symbol.attribute, symbolAttribute);
-	        if (doFill) {
+	        if (doFill && !parsedPath.isSvg) {
 	            if (fillCb) {
 	                fillCb(context, symbol.attribute, symbolAttribute);
 	            }
@@ -25791,7 +28213,7 @@
 	                context.fill();
 	            }
 	        }
-	        if (doStroke) {
+	        if (doStroke && !parsedPath.isSvg) {
 	            if (strokeCb) {
 	                strokeCb(context, symbol.attribute, symbolAttribute);
 	            }
@@ -26548,7 +28970,10 @@
 	    }
 	    allocate(data) {
 	        if (!this.pools.length) {
-	            return wrapCanvas(Object.assign({ nativeCanvas: application.global.createCanvas(data) }, data));
+	            return wrapCanvas({
+	                nativeCanvas: application.global.createCanvas(data),
+	                ...data
+	            });
 	        }
 	        const m = this.pools.pop();
 	        m.resize(data.width, data.height);
@@ -26562,7 +28987,10 @@
 	                height: canvas.height / canvas.dpr,
 	                dpr: canvas.dpr
 	            };
-	            return wrapCanvas(Object.assign({ nativeCanvas: application.global.createCanvas(data) }, data));
+	            return wrapCanvas({
+	                nativeCanvas: application.global.createCanvas(data),
+	                ...data
+	            });
 	        }
 	        const m = this.pools.pop();
 	        m.width = canvas.width;
@@ -27268,9 +29696,10 @@
 	        return;
 	    }
 	    draw(params) {
-	        this.drawContribution.draw(this, Object.assign({}, this.drawParams));
+	        this.drawContribution.draw(this, { ...this.drawParams });
 	    }
 	    afterDraw(params) {
+	        this.drawContribution.afterDraw && this.drawContribution.afterDraw(this, { ...this.drawParams });
 	        return;
 	    }
 	    render(groups, params) {
@@ -27353,10 +29782,8 @@
 	        graphic.forEachChildren(cb, reverse);
 	    }
 	}
-	function foreachAsync(graphic, defaultZIndex, cb, reverse = false) {
-	    return __awaiter(this, void 0, void 0, function* () {
-	        yield graphic.forEachChildrenAsync(cb, reverse);
-	    });
+	async function foreachAsync(graphic, defaultZIndex, cb, reverse = false) {
+	    await graphic.forEachChildrenAsync(cb, reverse);
 	}
 	function findNextGraphic(graphic, id, defaultZIndex, reverse = false) {
 	    const childMap = {};
@@ -27534,10 +29961,10 @@
 	                result = pickerService.pickGroup(graphic, point, params.parentMatrix, pickParams);
 	            }
 	            context.camera = null;
-	            context.restore();
 	            pickParams.in3dInterceptor = false;
 	            return result;
 	        }
+	        context.restore();
 	        return null;
 	    }
 	    initCanvasCtx(context) {
@@ -27964,12 +30391,12 @@
 	}
 	class OrthoCamera {
 	    set params(params) {
-	        this._params = Object.assign({}, params);
+	        this._params = { ...params };
 	        this._projectionMatrixCached = this.forceGetProjectionMatrix();
 	        this._viewMatrixCached = this.forceGetViewMatrix();
 	    }
 	    get params() {
-	        return Object.assign({}, this._params);
+	        return { ...this._params };
 	    }
 	    constructor(params) {
 	        this.params = params;
@@ -28183,9 +30610,9 @@
 	        }
 	    }
 	    constructor(canvas, dpr) {
-	        this.fillAttributes = Object.assign(Object.assign({}, DefaultFillStyle), { opacity: 1 });
-	        this.strokeAttributes = Object.assign(Object.assign({}, DefaultStrokeStyle), { opacity: 1 });
-	        this.textAttributes = Object.assign(Object.assign({}, DefaultTextStyle), { opacity: 1 });
+	        this.fillAttributes = { ...DefaultFillStyle, opacity: 1 };
+	        this.strokeAttributes = { ...DefaultStrokeStyle, opacity: 1 };
+	        this.textAttributes = { ...DefaultTextStyle, opacity: 1 };
 	        this._clearShadowStyle = false;
 	        this._clearFilterStyle = false;
 	        const context = canvas.nativeCanvas.getContext('2d');
@@ -29520,6 +31947,15 @@
 	            service.setActiveEnvContribution(this);
 	        }
 	    }
+	    getNativeAABBBounds(dom) {
+	        return new AABBBounds();
+	    }
+	    removeDom(dom) {
+	        return false;
+	    }
+	    createDom(params) {
+	        return null;
+	    }
 	    getDynamicCanvasCount() {
 	        return 999;
 	    }
@@ -29586,6 +32022,29 @@
 	    injectable()
 	], exports.BaseEnvContribution);
 
+	class DynamicB {
+	    get x1() {
+	        return this.dom.getBoundingClientRect().left;
+	    }
+	    get x2() {
+	        return this.dom.getBoundingClientRect().right;
+	    }
+	    get y1() {
+	        return this.dom.getBoundingClientRect().top;
+	    }
+	    get y2() {
+	        return this.dom.getBoundingClientRect().bottom;
+	    }
+	    get width() {
+	        return this.dom.getBoundingClientRect().width;
+	    }
+	    get height() {
+	        return this.dom.getBoundingClientRect().height;
+	    }
+	    constructor(dom) {
+	        this.dom = dom;
+	    }
+	}
 	function createImageElement$1(src, isSvg = false) {
 	    const img = document.createElement('img');
 	    img.crossOrigin = 'anonymous';
@@ -29646,6 +32105,48 @@
 	            y: nativeEvent.offsetY
 	        };
 	    }
+	    getNativeAABBBounds(_dom) {
+	        let dom = _dom;
+	        if (typeof _dom === 'string') {
+	            dom = new DOMParser().parseFromString(_dom, 'text/xml').firstChild;
+	        }
+	        if (dom.getBoundingClientRect) {
+	            const b = dom.getBoundingClientRect();
+	            return new DynamicB(b);
+	        }
+	        return new AABBBounds();
+	    }
+	    removeDom(dom) {
+	        dom.parentElement.removeChild(dom);
+	        return true;
+	    }
+	    createDom(params) {
+	        const { tagName = 'div', width, height, style, parent } = params;
+	        const element = document.createElement(tagName);
+	        if (style) {
+	            if (isString(style)) {
+	                element.setAttribute('style', style);
+	            }
+	            else {
+	                Object.keys(style).forEach(k => {
+	                    element.setAttribute(k, style[k]);
+	                });
+	            }
+	        }
+	        if (width != null) {
+	            element.style.width = `${width}px`;
+	        }
+	        if (height != null) {
+	            element.style.height = `${height}px`;
+	        }
+	        if (parent) {
+	            const pd = isString(parent) ? this.getElementById(parent) : parent;
+	            if (pd && pd.appendChild) {
+	                pd.appendChild(element);
+	            }
+	        }
+	        return element;
+	    }
 	    loadImage(url) {
 	        const imagePromise = createImageElement$1(url, false);
 	        return imagePromise
@@ -30316,30 +32817,28 @@
 	    injectable()
 	], NodeEnvContribution);
 
-	function makeUpCanvas(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
-	    return __awaiter(this, void 0, void 0, function* () {
-	        const dpr = wx.getSystemInfoSync().pixelRatio;
-	        for (let i = 0; i < canvasIdLists.length; i++) {
-	            const id = canvasIdLists[i];
-	            yield new Promise(resolve => {
-	                wx.createSelectorQuery()
-	                    .select(`#${id}`)
-	                    .fields({ node: true, size: true })
-	                    .exec((res) => {
-	                    const canvas = res[0].node;
-	                    const width = res[0].width;
-	                    const height = res[0].height;
-	                    canvas.width = width * dpr;
-	                    canvas.height = height * dpr;
-	                    canvasMap.set(id, canvas);
-	                    if (i >= freeCanvasIdx) {
-	                        freeCanvasList.push(canvas);
-	                    }
-	                    resolve(null);
-	                });
+	async function makeUpCanvas(domref, canvasIdLists, canvasMap, freeCanvasIdx, freeCanvasList) {
+	    const dpr = wx.getSystemInfoSync().pixelRatio;
+	    for (let i = 0; i < canvasIdLists.length; i++) {
+	        const id = canvasIdLists[i];
+	        await new Promise(resolve => {
+	            wx.createSelectorQuery()
+	                .select(`#${id}`)
+	                .fields({ node: true, size: true })
+	                .exec((res) => {
+	                const canvas = res[0].node;
+	                const width = res[0].width;
+	                const height = res[0].height;
+	                canvas.width = width * dpr;
+	                canvas.height = height * dpr;
+	                canvasMap.set(id, canvas);
+	                if (i >= freeCanvasIdx) {
+	                    freeCanvasList.push(canvas);
+	                }
+	                resolve(null);
 	            });
-	        }
-	    });
+	        });
+	    }
 	}
 	let WxEnvContribution = class WxEnvContribution extends exports.BaseEnvContribution {
 	    constructor() {
@@ -31335,14 +33834,22 @@
 	        }
 	        if (event.changedTouches.length > 0) {
 	            event.changedTouches.forEach((d, i) => {
-	                event.changedTouches[i] = Object.assign(Object.assign({}, event.changedTouches[i]), { offsetX: d.x, offsetY: d.y });
+	                event.changedTouches[i] = {
+	                    ...event.changedTouches[i],
+	                    offsetX: d.x,
+	                    offsetY: d.y
+	                };
 	            });
 	            event.offsetX = event.changedTouches[0].offsetX;
 	            event.offsetY = event.changedTouches[0].offsetY;
 	        }
 	        if (event.touches.length > 0) {
 	            event.touches.forEach((d, i) => {
-	                event.touches[i] = Object.assign(Object.assign({}, event.touches[i]), { offsetX: d.x, offsetY: d.y });
+	                event.touches[i] = {
+	                    ...event.touches[i],
+	                    offsetX: d.x,
+	                    offsetY: d.y
+	                };
 	            });
 	        }
 	        event.preventDefault = () => {
@@ -32436,7 +34943,12 @@
 	                this.canvas.applyPosition();
 	            }
 	        }
-	        params.renderService.render(group, Object.assign(Object.assign({ context: this.context, clear: (_a = params.background) !== null && _a !== void 0 ? _a : '#ffffff' }, params), userParams));
+	        params.renderService.render(group, {
+	            context: this.context,
+	            clear: (_a = params.background) !== null && _a !== void 0 ? _a : '#ffffff',
+	            ...params,
+	            ...userParams
+	        });
 	    }
 	    merge(layerHandlers) {
 	        layerHandlers.forEach(l => {
@@ -32451,7 +34963,11 @@
 	    drawTo(target, group, params) {
 	        var _a;
 	        const context = target.getContext();
-	        params.renderService.render(group, Object.assign(Object.assign({ context }, params), { clear: params.clear ? (_a = params.background) !== null && _a !== void 0 ? _a : '#fff' : undefined }));
+	        params.renderService.render(group, {
+	            context,
+	            ...params,
+	            clear: params.clear ? (_a = params.background) !== null && _a !== void 0 ? _a : '#fff' : undefined
+	        });
 	        return;
 	    }
 	    getContext() {
@@ -32499,7 +35015,13 @@
 	    }
 	    render(group, params) {
 	        var _a;
-	        params.renderService.render(group, Object.assign(Object.assign({ context: this.context }, params), { x: 0, y: 0, clear: (_a = params.background) !== null && _a !== void 0 ? _a : '#ffffff' }));
+	        params.renderService.render(group, {
+	            context: this.context,
+	            ...params,
+	            x: 0,
+	            y: 0,
+	            clear: (_a = params.background) !== null && _a !== void 0 ? _a : '#ffffff'
+	        });
 	    }
 	    prepare(dirtyBounds, params) {
 	        return;
@@ -32870,7 +35392,15 @@
 	        const idc = incrementalLayer.drawContribution || container.get(IncrementalDrawContribution);
 	        idc.dirtyBounds.setValue(-Infinity, -Infinity, Infinity, Infinity);
 	        idc.backupDirtyBounds.setValue(-Infinity, -Infinity, Infinity, Infinity);
-	        idc.draw(this.currentRenderService, Object.assign(Object.assign({}, drawContext), { drawContribution: idc, clear: 'transparent', layer: incrementalLayer.layer, context: incrementalContext, startAtId: group._uid, break: false }));
+	        idc.draw(this.currentRenderService, {
+	            ...drawContext,
+	            drawContribution: idc,
+	            clear: 'transparent',
+	            layer: incrementalLayer.layer,
+	            context: incrementalContext,
+	            startAtId: group._uid,
+	            break: false
+	        });
 	        incrementalLayer.drawContribution = idc;
 	        const nextGraphic = this._findNextGraphic(group);
 	        if (nextGraphic) {
@@ -32887,7 +35417,15 @@
 	                    subLayers.set(nextGraphic._uid, afterLayer);
 	                }
 	                const afterContext = afterLayer.layer.getNativeHandler().getContext();
-	                this.draw(this.currentRenderService, Object.assign(Object.assign({}, drawContext), { drawContribution: idc, clear: 'transparent', layer: afterLayer.layer, context: afterContext, startAtId: nextGraphic._uid, break: false }));
+	                this.draw(this.currentRenderService, {
+	                    ...drawContext,
+	                    drawContribution: idc,
+	                    clear: 'transparent',
+	                    layer: afterLayer.layer,
+	                    context: afterContext,
+	                    startAtId: nextGraphic._uid,
+	                    break: false
+	                });
 	            }
 	        }
 	    }
@@ -32962,7 +35500,14 @@
 	            context.fillRect(x, y, width, height);
 	        }
 	    }
+	    afterDraw(renderService, drawParams) {
+	        return;
+	    }
 	};
+	__decorate([
+	    inject(VGlobal),
+	    __metadata("design:type", Object)
+	], DefaultDrawContribution.prototype, "global", void 0);
 	__decorate([
 	    postConstruct(),
 	    __metadata("design:type", Function),
@@ -33282,178 +35827,164 @@
 	        this.defaultRenderMap.set(this.lineRender.numberType, this.lineRender);
 	        this.defaultRenderMap.set(this.areaRender.numberType, this.areaRender);
 	    }
-	    draw(renderService, drawContext) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            if (this.checkingForDrawPromise) {
-	                return;
-	            }
-	            this.lastRenderService = renderService;
-	            this.lastDrawContext = drawContext;
-	            this.checkingForDrawPromise = this.checkForDraw(drawContext);
-	            const skipDraw = yield this.checkingForDrawPromise;
-	            this.checkingForDrawPromise = null;
-	            if (skipDraw) {
-	                return;
-	            }
-	            this.currentRenderService = renderService;
-	            const { context, x = 0, y = 0 } = drawContext;
-	            if (!context) {
-	                return;
-	            }
-	            context.inuse = true;
-	            context.clearMatrix();
-	            context.setTransformForCurrent(true);
-	            context.save();
-	            drawContext.restartIncremental && this.clearScreen(this.currentRenderService, context, drawContext);
-	            context.translate(x, y, true);
-	            context.save();
-	            renderService.renderTreeRoots
-	                .sort((a, b) => {
-	                var _a, _b;
-	                return ((_a = a.attribute.zIndex) !== null && _a !== void 0 ? _a : DefaultAttribute.zIndex) - ((_b = b.attribute.zIndex) !== null && _b !== void 0 ? _b : DefaultAttribute.zIndex);
-	            })
-	                .forEach(group => {
-	                this.renderGroup(group, drawContext);
-	            });
-	            this.hooks.completeDraw.tap('top-draw', () => {
-	                context.restore();
-	                context.restore();
-	                context.draw();
-	                context.inuse = false;
-	                this.rendering = false;
-	            });
-	        });
-	    }
-	    _increaseRender(group, drawContext) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            this.rendering = true;
-	            yield this._renderIncrementalGroup(group, drawContext);
+	    async draw(renderService, drawContext) {
+	        if (this.checkingForDrawPromise) {
+	            return;
+	        }
+	        this.lastRenderService = renderService;
+	        this.lastDrawContext = drawContext;
+	        this.checkingForDrawPromise = this.checkForDraw(drawContext);
+	        const skipDraw = await this.checkingForDrawPromise;
+	        this.checkingForDrawPromise = null;
+	        if (skipDraw) {
 	            return;
+	        }
+	        this.currentRenderService = renderService;
+	        const { context, x = 0, y = 0 } = drawContext;
+	        if (!context) {
+	            return;
+	        }
+	        context.inuse = true;
+	        context.clearMatrix();
+	        context.setTransformForCurrent(true);
+	        context.save();
+	        drawContext.restartIncremental && this.clearScreen(this.currentRenderService, context, drawContext);
+	        context.translate(x, y, true);
+	        context.save();
+	        renderService.renderTreeRoots
+	            .sort((a, b) => {
+	            var _a, _b;
+	            return ((_a = a.attribute.zIndex) !== null && _a !== void 0 ? _a : DefaultAttribute.zIndex) - ((_b = b.attribute.zIndex) !== null && _b !== void 0 ? _b : DefaultAttribute.zIndex);
+	        })
+	            .forEach(group => {
+	            this.renderGroup(group, drawContext);
 	        });
+	        this.hooks.completeDraw.tap('top-draw', () => {
+	            context.restore();
+	            context.restore();
+	            context.draw();
+	            context.inuse = false;
+	            this.rendering = false;
+	        });
+	    }
+	    async _increaseRender(group, drawContext) {
+	        this.rendering = true;
+	        await this._renderIncrementalGroup(group, drawContext);
+	        return;
 	    }
-	    _renderIncrementalGroup(group, drawContext) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            this.count = group.count;
-	            yield new Promise(resolve => {
-	                this.renderItem(group, drawContext, {
-	                    drawingCb: () => __awaiter(this, void 0, void 0, function* () {
-	                        if (group.count === 2) {
-	                            const graphic = group.getChildAt(0);
-	                            if (graphic.incremental && graphic.attribute.segments) {
-	                                if (!graphic.incrementalAt) {
-	                                    graphic.incrementalAt = 0;
-	                                }
-	                                while (graphic.incrementalAt < graphic.attribute.segments.length) {
-	                                    drawContext.multiGraphicOptions = {
-	                                        startAtIdx: graphic.incrementalAt,
-	                                        length: graphic.incremental
-	                                    };
-	                                    this.renderItem(graphic, drawContext);
-	                                    graphic.incrementalAt += graphic.incremental;
-	                                    yield this.waitToNextFrame();
-	                                }
+	    async _renderIncrementalGroup(group, drawContext) {
+	        this.count = group.count;
+	        await new Promise(resolve => {
+	            this.renderItem(group, drawContext, {
+	                drawingCb: async () => {
+	                    if (group.count === 2) {
+	                        const graphic = group.getChildAt(0);
+	                        if (graphic.incremental && graphic.attribute.segments) {
+	                            if (!graphic.incrementalAt) {
+	                                graphic.incrementalAt = 0;
 	                            }
-	                            else {
+	                            while (graphic.incrementalAt < graphic.attribute.segments.length) {
+	                                drawContext.multiGraphicOptions = {
+	                                    startAtIdx: graphic.incrementalAt,
+	                                    length: graphic.incremental
+	                                };
 	                                this.renderItem(graphic, drawContext);
+	                                graphic.incrementalAt += graphic.incremental;
+	                                await this.waitToNextFrame();
 	                            }
-	                            resolve(false);
-	                            return;
 	                        }
-	                        yield foreachAsync(group, DefaultAttribute.zIndex, (item, i) => {
-	                            if (this.status === STATUS.STOP) {
-	                                return true;
-	                            }
-	                            if (item.isContainer) {
-	                                return false;
-	                            }
-	                            if (i < this.currentIdx) {
-	                                return false;
-	                            }
-	                            const frameTail = this.currFrameStartAt + group.incremental;
-	                            if (i < frameTail) {
-	                                this.currentIdx = i + 1;
-	                                this.renderItem(item, drawContext);
-	                            }
-	                            if (i === frameTail - 1) {
-	                                this.currFrameStartAt = this.currentIdx;
-	                                return this.waitToNextFrame();
-	                            }
-	                            return false;
-	                        });
+	                        else {
+	                            this.renderItem(graphic, drawContext);
+	                        }
 	                        resolve(false);
-	                    })
-	                });
+	                        return;
+	                    }
+	                    await foreachAsync(group, DefaultAttribute.zIndex, (item, i) => {
+	                        if (this.status === STATUS.STOP) {
+	                            return true;
+	                        }
+	                        if (item.isContainer) {
+	                            return false;
+	                        }
+	                        if (i < this.currentIdx) {
+	                            return false;
+	                        }
+	                        const frameTail = this.currFrameStartAt + group.incremental;
+	                        if (i < frameTail) {
+	                            this.currentIdx = i + 1;
+	                            this.renderItem(item, drawContext);
+	                        }
+	                        if (i === frameTail - 1) {
+	                            this.currFrameStartAt = this.currentIdx;
+	                            return this.waitToNextFrame();
+	                        }
+	                        return false;
+	                    });
+	                    resolve(false);
+	                }
 	            });
-	            this.hooks.completeDraw.call();
 	        });
+	        this.hooks.completeDraw.call();
 	    }
-	    waitToNextFrame() {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            return new Promise(resolve => {
-	                this.global.getRequestAnimationFrame()(() => {
-	                    resolve(false);
-	                });
+	    async waitToNextFrame() {
+	        return new Promise(resolve => {
+	            this.global.getRequestAnimationFrame()(() => {
+	                resolve(false);
 	            });
 	        });
 	    }
-	    checkForDraw(drawContext) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            let skip = this.rendering;
-	            if (drawContext.restartIncremental) {
-	                skip = false;
-	                yield this.forceStop();
-	                this.resetToInit();
-	            }
-	            return skip;
-	        });
+	    async checkForDraw(drawContext) {
+	        let skip = this.rendering;
+	        if (drawContext.restartIncremental) {
+	            skip = false;
+	            await this.forceStop();
+	            this.resetToInit();
+	        }
+	        return skip;
 	    }
-	    forceStop() {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            if (this.rendering) {
-	                this.status = STATUS.STOP;
-	                yield new Promise(resolve => {
-	                    this.hooks.completeDraw.tap('stopCb', () => {
-	                        this.status = STATUS.NORMAL;
-	                        this.hooks.completeDraw.taps = this.hooks.completeDraw.taps.filter(item => {
-	                            return item.name !== 'stopCb';
-	                        });
-	                        resolve(false);
+	    async forceStop() {
+	        if (this.rendering) {
+	            this.status = STATUS.STOP;
+	            await new Promise(resolve => {
+	                this.hooks.completeDraw.tap('stopCb', () => {
+	                    this.status = STATUS.NORMAL;
+	                    this.hooks.completeDraw.taps = this.hooks.completeDraw.taps.filter(item => {
+	                        return item.name !== 'stopCb';
 	                    });
+	                    resolve(false);
 	                });
-	            }
-	        });
+	            });
+	        }
 	    }
 	    resetToInit() {
 	        this.currFrameStartAt = 0;
 	        this.currentIdx = 0;
 	    }
-	    renderGroup(group, drawContext) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            if (drawContext.break || group.attribute.visibleAll === false) {
-	                return;
-	            }
-	            if (group.incremental && drawContext.startAtId === group._uid) {
-	                yield this._increaseRender(group, drawContext);
-	                drawContext.break = true;
-	                return;
-	            }
-	            yield new Promise(resolve => {
-	                this.renderItem(group, drawContext, {
-	                    drawingCb: () => __awaiter(this, void 0, void 0, function* () {
-	                        yield foreachAsync(group, DefaultAttribute.zIndex, (item) => __awaiter(this, void 0, void 0, function* () {
-	                            if (drawContext.break) {
-	                                return;
-	                            }
-	                            if (item.isContainer) {
-	                                yield this.renderGroup(item, drawContext);
-	                            }
-	                            else {
-	                                return;
-	                            }
-	                        }));
-	                        resolve(false);
-	                    })
-	                });
+	    async renderGroup(group, drawContext) {
+	        if (drawContext.break || group.attribute.visibleAll === false) {
+	            return;
+	        }
+	        if (group.incremental && drawContext.startAtId === group._uid) {
+	            await this._increaseRender(group, drawContext);
+	            drawContext.break = true;
+	            return;
+	        }
+	        await new Promise(resolve => {
+	            this.renderItem(group, drawContext, {
+	                drawingCb: async () => {
+	                    await foreachAsync(group, DefaultAttribute.zIndex, async (item) => {
+	                        if (drawContext.break) {
+	                            return;
+	                        }
+	                        if (item.isContainer) {
+	                            await this.renderGroup(item, drawContext);
+	                        }
+	                        else {
+	                            return;
+	                        }
+	                    });
+	                    resolve(false);
+	                }
 	            });
 	        });
 	    }
@@ -34727,6 +37258,7 @@
 	    __metadata("design:paramtypes", [Object])
 	], DefaultCanvasPathPicker);
 
+	createRect({});
 	let DefaultCanvasSymbolPicker = class DefaultCanvasSymbolPicker extends BasePicker {
 	    constructor(canvasRenderer) {
 	        super();
@@ -34739,11 +37271,12 @@
 	        if (!pickContext) {
 	            return false;
 	        }
+	        const parsedPath = symbol.getParsedPath();
 	        if (!pickContext.camera) {
 	            if (!symbol.AABBBounds.containsPoint(point)) {
 	                return false;
 	            }
-	            if (symbol.attribute.pickMode === 'imprecise') {
+	            if (parsedPath.isSvg || symbol.attribute.pickMode === 'imprecise') {
 	                return true;
 	            }
 	        }
@@ -35996,8 +38529,20 @@
 	                if (!subLayer || !subLayer.drawContribution) {
 	                    return;
 	                }
-	                subLayer.drawContribution.draw(stage.renderService, Object.assign({ x: stage.x, y: stage.y, width: layer.viewWidth, height: layer.viewHeight, stage,
-	                    layer, clear: 'transparent', renderService: stage.renderService, updateBounds: false, startAtId: group._uid, context: subLayer.layer.getNativeHandler().getContext() }, this.nextUserParams));
+	                subLayer.drawContribution.draw(stage.renderService, {
+	                    x: stage.x,
+	                    y: stage.y,
+	                    width: layer.viewWidth,
+	                    height: layer.viewHeight,
+	                    stage,
+	                    layer,
+	                    clear: 'transparent',
+	                    renderService: stage.renderService,
+	                    updateBounds: false,
+	                    startAtId: group._uid,
+	                    context: subLayer.layer.getNativeHandler().getContext(),
+	                    ...this.nextUserParams
+	                });
 	            });
 	            this.nextUserParams = {};
 	            this.nextFrameRenderGroupSet.clear();
@@ -36005,6 +38550,111 @@
 	    }
 	}
 
+	class HtmlAttributePlugin {
+	    constructor() {
+	        this.name = 'HtmlAttributePlugin';
+	        this.activeEvent = 'onRegister';
+	        this._uid = Generator.GenAutoIncrementId();
+	        this.key = this.name + this._uid;
+	    }
+	    activate(context) {
+	        this.pluginService = context;
+	        context.stage.hooks.afterRender.tap(this.key, stage => {
+	            if (!(stage && stage === this.pluginService.stage)) {
+	                return;
+	            }
+	            this.drawHTML(context.stage.renderService);
+	        });
+	    }
+	    deactivate(context) {
+	        context.stage.hooks.afterRender.taps = context.stage.hooks.afterRender.taps.filter(item => {
+	            return item.name !== this.key;
+	        });
+	    }
+	    drawHTML(renderService) {
+	        if (application.global.env === 'browser') {
+	            renderService.renderTreeRoots
+	                .sort((a, b) => {
+	                var _a, _b;
+	                return ((_a = a.attribute.zIndex) !== null && _a !== void 0 ? _a : DefaultAttribute.zIndex) - ((_b = b.attribute.zIndex) !== null && _b !== void 0 ? _b : DefaultAttribute.zIndex);
+	            })
+	                .forEach(group => {
+	                this.renderGroupHTML(group);
+	            });
+	        }
+	    }
+	    renderGroupHTML(group) {
+	        this.renderGraphicHTML(group);
+	        group.forEachChildren((g) => {
+	            this.renderGraphicHTML(g);
+	        });
+	    }
+	    renderGraphicHTML(graphic) {
+	        const { html } = graphic.attribute;
+	        if (!html) {
+	            return;
+	        }
+	        const stage = graphic.stage;
+	        if (!stage) {
+	            return;
+	        }
+	        const { dom, container, width, height, style, anchorType = 'boundsLeftTop' } = html;
+	        if (!graphic.bindDom) {
+	            graphic.bindDom = new Map();
+	        }
+	        const lastDom = graphic.bindDom.get(dom);
+	        if (lastDom && !(container && container !== lastDom.container)) {
+	            return;
+	        }
+	        graphic.bindDom.forEach(({ wrapGroup }) => {
+	            application.global.removeDom(wrapGroup);
+	        });
+	        let nativeDom;
+	        if (typeof dom === 'string') {
+	            nativeDom = new DOMParser().parseFromString(dom, 'text/xml').firstChild;
+	        }
+	        else {
+	            nativeDom = dom;
+	        }
+	        let nativeContainer;
+	        const _container = container || (stage.params.enableHtmlAttribute === true ? null : stage.params.enableHtmlAttribute);
+	        if (_container) {
+	            if (typeof _container === 'string') {
+	                nativeContainer = application.global.getElementById(_container);
+	            }
+	            else {
+	                nativeContainer = _container;
+	            }
+	        }
+	        else {
+	            nativeContainer = graphic.stage.window.getContainer();
+	        }
+	        const wrapGroup = application.global.createDom({ tagName: 'div', width, height, style, parent: nativeContainer });
+	        if (wrapGroup) {
+	            wrapGroup.appendChild(nativeDom);
+	            graphic.bindDom.set(dom, { dom: nativeDom, container, wrapGroup: wrapGroup });
+	        }
+	        wrapGroup.style.pointerEvents = 'none';
+	        if (!wrapGroup.style.position) {
+	            wrapGroup.style.position = 'absolute';
+	        }
+	        let left = 0;
+	        let top = 0;
+	        if (anchorType === 'position') {
+	            const matrix = graphic.transMatrix;
+	            left = matrix.e;
+	            top = matrix.f;
+	        }
+	        else {
+	            const b = graphic.AABBBounds;
+	            left = b.x1;
+	            top = b.y1;
+	        }
+	        wrapGroup.style.left = `${left}px`;
+	        wrapGroup.style.top = `${top}px`;
+	    }
+	}
+
 	const globalBounds = new AABBBounds();
 	class DirtyBoundsPlugin {
 	    constructor() {
@@ -36310,8 +38960,8 @@
 
 	const defaultTicker = new DefaultTicker();
 	defaultTicker.addTimeline(defaultTimeline);
-	const TICKER_FPS = 60;
-	defaultTicker.setFPS(TICKER_FPS);
+	const DEFAULT_TICKER_FPS = 60;
+	defaultTicker.setFPS(DEFAULT_TICKER_FPS);
 
 	class DirectionalLight {
 	    constructor(dir, color, ambient = 0.8) {
@@ -36420,6 +39070,7 @@
 	            this._afterNextRenderCbs && this._afterNextRenderCbs.forEach(cb => cb(stage));
 	            this._afterNextRenderCbs = null;
 	        };
+	        this.params = params;
 	        this.theme = new Theme();
 	        this.hooks = {
 	            beforeRender: new SyncHook(['stage']),
@@ -36485,6 +39136,9 @@
 	        if (params.disableDirtyBounds === false) {
 	            this.enableDirtyBounds();
 	        }
+	        if (params.enableHtmlAttribute) {
+	            this.enableHtmlAttribute(params.enableHtmlAttribute);
+	        }
 	        params.enableLayout && this.enableLayout();
 	        this.hooks.beforeRender.tap('constructor', this.beforeRender);
 	        this.hooks.afterRender.tap('constructor', this.afterRender);
@@ -36495,13 +39149,16 @@
 	    }
 	    get3dOptions(options) {
 	        const { center = { x: this.width / 2, y: this.height / 2, z: 0, dx: 0, dy: 0, dz: 0 }, light = {}, alpha = 0, beta = 0, camera, fieldRatio = 1, fieldDepth } = options;
-	        return Object.assign(Object.assign({}, options), { center,
+	        return {
+	            ...options,
+	            center,
 	            light,
 	            alpha,
 	            beta,
 	            camera,
 	            fieldRatio,
-	            fieldDepth });
+	            fieldDepth
+	        };
 	    }
 	    set3dOptions(options) {
 	        var _a, _b, _c, _d, _e, _f;
@@ -36643,6 +39300,22 @@
 	            plugin.deactivate(this.pluginService);
 	        });
 	    }
+	    enableHtmlAttribute(container) {
+	        if (this.htmlAttribute) {
+	            return;
+	        }
+	        this.htmlAttribute = container;
+	        this.pluginService.register(new HtmlAttributePlugin());
+	    }
+	    disableHtmlAttribute() {
+	        if (!this.htmlAttribute) {
+	            return;
+	        }
+	        this.htmlAttribute = false;
+	        this.pluginService.findPluginsByName('HtmlAttributePlugin').forEach(plugin => {
+	            plugin.deactivate(this.pluginService);
+	        });
+	    }
 	    tryUpdateAABBBounds() {
 	        const viewBox = this._viewBox;
 	        this._AABBBounds.setValue(viewBox.x1, viewBox.y1, viewBox.x2, viewBox.y2);
@@ -36688,7 +39361,7 @@
 	                renderService: this.renderService,
 	                background: layer === this.defaultLayer ? this.background : undefined,
 	                updateBounds: !!this.dirtyBounds
-	            }, Object.assign({ renderStyle: this.renderStyle }, params));
+	            }, { renderStyle: this.renderStyle, ...params });
 	        });
 	        this.combineLayersToWindow();
 	        this.nextFrameRenderLayerSet.clear();
@@ -36731,7 +39404,7 @@
 	                        renderService: this.renderService,
 	                        background: layer === this.defaultLayer ? this.background : undefined,
 	                        updateBounds: !!this.dirtyBounds
-	                    }, Object.assign({ renderStyle: this.renderStyle }, (this.lastRenderparams || {})));
+	                    }, { renderStyle: this.renderStyle, ...(this.lastRenderparams || {}) });
 	                }
 	            });
 	            this.combineLayersToWindow();
@@ -36759,7 +39432,7 @@
 	        this.forEachChildren(c => {
 	            c.resizeView(w, h);
 	        });
-	        this.camera && (this.camera.params = Object.assign(Object.assign({}, this.camera.params), { right: this.width, bottom: this.height }));
+	        this.camera && (this.camera.params = { ...this.camera.params, right: this.width, bottom: this.height });
 	        rerender && this.render();
 	    }
 	    setViewBox(x, y, w, h, rerender) {
@@ -36835,7 +39508,13 @@
 	    }
 	    renderTo(window, params) {
 	        this.forEachChildren((layer, i) => {
-	            layer.drawTo(window, Object.assign(Object.assign({}, params), { renderService: this.renderService, background: layer === this.defaultLayer ? this.background : undefined, clear: i === 0, updateBounds: !!this.dirtyBounds }));
+	            layer.drawTo(window, {
+	                ...params,
+	                renderService: this.renderService,
+	                background: layer === this.defaultLayer ? this.background : undefined,
+	                clear: i === 0,
+	                updateBounds: !!this.dirtyBounds
+	            });
 	        });
 	    }
 	    renderToNewWindow(fullImage = true) {
@@ -36908,7 +39587,137 @@
 	    'rect'
 	];
 
-	const version = "0.14.2";
+	const REACT_TO_CANOPUS_EVENTS = {
+	    onPointerDown: 'pointerdown',
+	    onPointerUp: 'pointerup',
+	    onPointerUpOutside: 'pointerupoutside',
+	    onPointerTap: 'pointertap',
+	    onPointerOver: 'pointerover',
+	    onPointerMove: 'pointermove',
+	    onPointerEnter: 'pointerenter',
+	    onPointerLeave: 'pointerleave',
+	    onPointerOut: 'pointerout',
+	    onMouseDown: 'mousedown',
+	    onMouseUp: 'mouseup',
+	    onMouseUpOutside: 'mouseupoutside',
+	    onMouseMove: 'mousemove',
+	    onMouseOver: 'mouseover',
+	    onMouseOut: 'mouseout',
+	    onMouseEnter: 'mouseenter',
+	    onMouseLeave: 'mouseleave',
+	    onPinch: 'pinch',
+	    onPinchStart: 'pinchstart',
+	    onPinchEnd: 'pinchend',
+	    onPan: 'pan',
+	    onPanStart: 'panstart',
+	    onPanEnd: 'panend',
+	    onDrag: 'drag',
+	    onDragStart: 'dragstart',
+	    onDragEnter: 'dragenter',
+	    onDragLeave: 'dragleave',
+	    onDragOver: 'dragover',
+	    onDragEnd: 'dragend',
+	    onRightDown: 'rightdown',
+	    onRightUp: 'rightup',
+	    onRightUpOutside: 'rightupoutside',
+	    onTouchStart: 'touchstart',
+	    onTouchEnd: 'touchend',
+	    onTouchEndOutside: 'touchendoutside',
+	    onTouchMove: 'touchmove',
+	    onTouchCancel: 'touchcancel',
+	    onPress: 'press',
+	    onPressUp: 'pressup',
+	    onPressEnd: 'pressend',
+	    onSwipe: 'swipe',
+	    onDrop: 'drop',
+	    onWeel: 'wheel',
+	    onClick: 'click',
+	    onDblClick: 'dblclick'
+	};
+	const REACT_TO_CANOPUS_EVENTS_LIST = Object.keys(REACT_TO_CANOPUS_EVENTS);
+	function VArc(params) {
+	    return createArc(params ? params.attribute : {});
+	}
+	function VArc3d(params) {
+	    return createArc3d(params ? params.attribute : {});
+	}
+	function VArea(params) {
+	    return createArea(params ? params.attribute : {});
+	}
+	function VCircle(params) {
+	    return createCircle(params ? params.attribute : {});
+	}
+	function VGroup(params) {
+	    return createGroup(params ? params.attribute : {});
+	}
+	function VGlyph(params) {
+	    return createGlyph(params ? params.attribute : {});
+	}
+	function VImage(params) {
+	    return createImage(params ? params.attribute : {});
+	}
+	function VLine(params) {
+	    return createLine(params ? params.attribute : {});
+	}
+	function VPath(params) {
+	    return createPath(params ? params.attribute : {});
+	}
+	function VPolygon(params) {
+	    return createPolygon(params ? params.attribute : {});
+	}
+	function VPyramid3d(params) {
+	    return createPyramid3d(params ? params.attribute : {});
+	}
+	function VRect(params) {
+	    return createRect(params ? params.attribute : {});
+	}
+	function VRect3d(params) {
+	    return createRect3d(params ? params.attribute : {});
+	}
+	function VSymbol(params) {
+	    return createSymbol(params ? params.attribute : {});
+	}
+	function VText(params) {
+	    return createText(params ? params.attribute : {});
+	}
+
+	function jsx(type, config, ...children) {
+	    const { key, attribute, ...props } = config || {};
+	    let c = type;
+	    if (isString(type)) {
+	        c = graphicCreator[type];
+	    }
+	    let childrenList = [];
+	    if (children.length) {
+	        childrenList = children.length === 1 ? children[0] : children;
+	    }
+	    const g = c.prototype.type ? new c(attribute) : c(config);
+	    if (childrenList && isArray(childrenList)) {
+	        childrenList.forEach((c) => {
+	            g.add(c);
+	        });
+	    }
+	    else {
+	        g.add(childrenList);
+	    }
+	    Object.keys(props).forEach(k => {
+	        const en = REACT_TO_CANOPUS_EVENTS[k];
+	        if (en) {
+	            g.on(en, props[k]);
+	        }
+	    });
+	    return g;
+	}
+	class Fragment {
+	    constructor() {
+	        this.children = [];
+	    }
+	    add(g) {
+	        this.children.push(g);
+	    }
+	}
+
+	const version = "0.15.0-alpha.0";
 
 	exports.ACustomAnimate = ACustomAnimate;
 	exports.ARC3D_NUMBER_TYPE = ARC3D_NUMBER_TYPE;
@@ -36988,6 +39797,7 @@
 	exports.FederatedMouseEvent = FederatedMouseEvent;
 	exports.FederatedPointerEvent = FederatedPointerEvent;
 	exports.FederatedWheelEvent = FederatedWheelEvent;
+	exports.Fragment = Fragment;
 	exports.GLYPH_NUMBER_TYPE = GLYPH_NUMBER_TYPE;
 	exports.GRAPHIC_UPDATE_TAG_KEY = GRAPHIC_UPDATE_TAG_KEY;
 	exports.GROUP_NUMBER_TYPE = GROUP_NUMBER_TYPE;
@@ -37048,6 +39858,8 @@
 	exports.Pyramid3d = Pyramid3d;
 	exports.Pyramid3dRender = Pyramid3dRender;
 	exports.RAFTickHandler = RAFTickHandler;
+	exports.REACT_TO_CANOPUS_EVENTS = REACT_TO_CANOPUS_EVENTS;
+	exports.REACT_TO_CANOPUS_EVENTS_LIST = REACT_TO_CANOPUS_EVENTS_LIST;
 	exports.RECT3D_NUMBER_TYPE = RECT3D_NUMBER_TYPE;
 	exports.RECT_NUMBER_TYPE = RECT_NUMBER_TYPE;
 	exports.RICHTEXT_NUMBER_TYPE = RICHTEXT_NUMBER_TYPE;
@@ -37064,6 +39876,10 @@
 	exports.RichText = RichText;
 	exports.RichTextRender = RichTextRender;
 	exports.RotateBySphereAnimate = RotateBySphereAnimate;
+	exports.SVG_ATTRIBUTE_MAP = SVG_ATTRIBUTE_MAP;
+	exports.SVG_ATTRIBUTE_MAP_KEYS = SVG_ATTRIBUTE_MAP_KEYS;
+	exports.SVG_PARSE_ATTRIBUTE_MAP = SVG_PARSE_ATTRIBUTE_MAP;
+	exports.SVG_PARSE_ATTRIBUTE_MAP_KEYS = SVG_PARSE_ATTRIBUTE_MAP_KEYS;
 	exports.SYMBOL_NUMBER_TYPE = SYMBOL_NUMBER_TYPE;
 	exports.SegContext = SegContext;
 	exports.Stage = Stage;
@@ -37081,6 +39897,21 @@
 	exports.Theme = Theme;
 	exports.TimeOutTickHandler = TimeOutTickHandler;
 	exports.TransformUtil = TransformUtil;
+	exports.VArc = VArc;
+	exports.VArc3d = VArc3d;
+	exports.VArea = VArea;
+	exports.VCircle = VCircle;
+	exports.VGlyph = VGlyph;
+	exports.VGroup = VGroup;
+	exports.VImage = VImage;
+	exports.VLine = VLine;
+	exports.VPath = VPath;
+	exports.VPolygon = VPolygon;
+	exports.VPyramid3d = VPyramid3d;
+	exports.VRect = VRect;
+	exports.VRect3d = VRect3d;
+	exports.VSymbol = VSymbol;
+	exports.VText = VText;
 	exports.VWindow = VWindow;
 	exports.WindowHandlerContribution = WindowHandlerContribution;
 	exports.addArcToBezierPath = addArcToBezierPath$1;
@@ -37172,6 +40003,7 @@
 	exports.incrementalAddTo = incrementalAddTo;
 	exports.intersect = intersect;
 	exports.isTransformKey = isTransformKey;
+	exports.jsx = jsx;
 	exports.layerService = layerService;
 	exports.loadFeishuContributions = loadFeishuContributions;
 	exports.loadTaroContributions = loadTaroContributions;