@visactor/vrender-core 1.1.0-alpha.25 → 1.1.0-alpha.27

package/dist/index.es.js

@@ -5984,309 +5984,6 @@ const builtInSymbolStrMap = {
     roundLine: 'M 1.2392 -0.258 L -1.3432 -0.258 C -1.4784 -0.258 -1.588 -0.1436 -1.588 -0.002 c 0 0.1416 0.1096 0.256 0.2448 0.256 l 2.5824 0 c 0.1352 0 0.2448 -0.1144 0.2448 -0.256 C 1.484 -0.1436 1.3744 -0.258 1.2392 -0.258 z'
 };
 
-function getAllMatches(string, regex) {
-    const matches = [];
-    let match = regex.exec(string);
-    while (match) {
-        const allmatches = [];
-        allmatches.startIndex = regex.lastIndex - match[0].length;
-        const len = match.length;
-        for (let index = 0; index < len; index++) {
-            allmatches.push(match[index]);
-        }
-        matches.push(allmatches);
-        match = regex.exec(string);
-    }
-    return matches;
-}
-
-class XmlNode {
-    constructor(tagname) {
-        this.tagname = tagname;
-        this.child = [];
-        this[':@'] = {};
-    }
-    add(key, val) {
-        if (key === '__proto__') {
-            key = '#__proto__';
-        }
-        this.child.push({ [key]: val });
-    }
-    addChild(node) {
-        if (node.tagname === '__proto__') {
-            node.tagname = '#__proto__';
-        }
-        if (node[':@'] && Object.keys(node[':@']).length > 0) {
-            this.child.push({ [node.tagname]: node.child, [':@']: node[':@'] });
-        }
-        else {
-            this.child.push({ [node.tagname]: node.child });
-        }
-    }
-}
-function findClosingIndex(xmlData, str, i, errMsg) {
-    const closingIndex = xmlData.indexOf(str, i);
-    if (closingIndex === -1) {
-        throw new Error(errMsg);
-    }
-    else {
-        return closingIndex + str.length - 1;
-    }
-}
-function tagExpWithClosingIndex(xmlData, i, closingChar = '>') {
-    let attrBoundary;
-    let tagExp = '';
-    for (let index = i; index < xmlData.length; index++) {
-        let ch = xmlData[index];
-        if (attrBoundary) {
-            if (ch === attrBoundary) {
-                attrBoundary = '';
-            }
-        }
-        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 readTagExp(xmlData, i, removeNSPrefix, closingChar = '>') {
-    const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
-    if (!result) {
-        return;
-    }
-    let tagExp = result.data;
-    const closeIndex = result.index;
-    const separatorIndex = tagExp.search(/\s/);
-    let tagName = tagExp;
-    let attrExpPresent = true;
-    if (separatorIndex !== -1) {
-        tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
-        tagExp = tagExp.substr(separatorIndex + 1);
-    }
-    const rawTagName = tagName;
-    if (removeNSPrefix) {
-        const 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,
-        rawTagName: rawTagName
-    };
-}
-const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
-class OrderedObjParser {
-    constructor(options) {
-        this.currentNode = null;
-        this.options = options;
-        this.tagsNodeStack = [];
-        this.docTypeEntities = {};
-    }
-    addChild(currentNode, childNode, jPath) {
-        const result = childNode.tagname;
-        if (typeof result === 'string') {
-            childNode.tagname = result;
-            currentNode.addChild(childNode);
-        }
-        else {
-            currentNode.addChild(childNode);
-        }
-    }
-    buildAttributesMap(attrStr, jPath, tagName) {
-        const attrs = {};
-        if (!attrStr) {
-            return;
-        }
-        const matches = getAllMatches(attrStr, attrsRegx);
-        const len = matches.length;
-        for (let i = 0; i < len; i++) {
-            const attrName = matches[i][1];
-            const oldVal = matches[i][4];
-            const aName = attrName;
-            if (attrName) {
-                if (oldVal !== undefined) {
-                    attrs[aName] = isNaN(oldVal) ? oldVal : Number(oldVal);
-                }
-                else {
-                    attrs[aName] = true;
-                }
-            }
-        }
-        return attrs;
-    }
-    parseXml(xmlData) {
-        xmlData = xmlData.replace(/\r\n?/g, '\n');
-        const xmlObj = new XmlNode('!xml');
-        let currentNode = xmlObj;
-        let textData = '';
-        let jPath = '';
-        for (let i = 0; i < xmlData.length; i++) {
-            const ch = xmlData[i];
-            if (ch === '<') {
-                if (xmlData[i + 1] === '/') {
-                    const closeIndex = findClosingIndex(xmlData, '>', i, 'Closing Tag is not closed.');
-                    const propIndex = jPath.lastIndexOf('.');
-                    jPath = jPath.substring(0, propIndex);
-                    currentNode = this.tagsNodeStack.pop();
-                    if (currentNode && currentNode.child && textData) {
-                        currentNode.child[currentNode.child.length - 1][':@'] &&
-                            (currentNode.child[currentNode.child.length - 1][':@'].text = textData);
-                    }
-                    textData = '';
-                    i = closeIndex;
-                }
-                else if (xmlData[i + 1] === '?') {
-                    const tagData = readTagExp(xmlData, i, false, '?>');
-                    i = tagData.closeIndex + 1;
-                }
-                else if (xmlData.substr(i + 1, 3) === '!--') {
-                    const endIndex = findClosingIndex(xmlData, '-->', i + 4, 'Comment is not closed.');
-                    i = endIndex;
-                }
-                else {
-                    const result = readTagExp(xmlData, i, false);
-                    let tagName = result.tagName;
-                    let tagExp = result.tagExp;
-                    const attrExpPresent = result.attrExpPresent;
-                    const closeIndex = result.closeIndex;
-                    if (tagName !== xmlObj.tagname) {
-                        jPath += jPath ? '.' + tagName : tagName;
-                    }
-                    if (tagExp.length > 0 && tagExp.lastIndexOf('/') === tagExp.length - 1) {
-                        if (tagName[tagName.length - 1] === '/') {
-                            tagName = tagName.substr(0, tagName.length - 1);
-                            jPath = jPath.substr(0, jPath.length - 1);
-                            tagExp = tagName;
-                        }
-                        else {
-                            tagExp = tagExp.substr(0, tagExp.length - 1);
-                        }
-                        const childNode = new XmlNode(tagName);
-                        if (tagName !== tagExp && attrExpPresent) {
-                            childNode[':@'] = this.buildAttributesMap(tagExp, jPath, tagName);
-                        }
-                        this.addChild(currentNode, childNode, jPath);
-                        jPath = jPath.substr(0, jPath.lastIndexOf('.'));
-                    }
-                    else {
-                        const childNode = new XmlNode(tagName);
-                        this.tagsNodeStack.push(currentNode);
-                        if (tagName !== tagExp && attrExpPresent) {
-                            childNode[':@'] = this.buildAttributesMap(tagExp, jPath, tagName);
-                        }
-                        this.addChild(currentNode, childNode, jPath);
-                        currentNode = childNode;
-                    }
-                    textData = '';
-                    i = closeIndex;
-                }
-            }
-            else {
-                textData += xmlData[i];
-            }
-        }
-        return xmlObj.child;
-    }
-}
-
-function prettify(node, options) {
-    return compress(node);
-}
-function compress(arr, jPath) {
-    const compressedObj = {};
-    for (let i = 0; i < arr.length; i++) {
-        const tagObj = arr[i];
-        const property = propName(tagObj);
-        if (property === undefined) {
-            continue;
-        }
-        else if (tagObj[property]) {
-            const val = compress(tagObj[property]);
-            isLeafTag(val);
-            if (tagObj[':@']) {
-                assignAttributes(val, tagObj[':@']);
-            }
-            if (compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
-                if (!Array.isArray(compressedObj[property])) {
-                    compressedObj[property] = [compressedObj[property]];
-                }
-                compressedObj[property].push(val);
-            }
-            else {
-                compressedObj[property] = val;
-            }
-        }
-    }
-    return compressedObj;
-}
-function propName(obj) {
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        if (key !== ':@') {
-            return key;
-        }
-    }
-}
-function assignAttributes(obj, attrMap, jpath) {
-    if (attrMap) {
-        const keys = Object.keys(attrMap);
-        const len = keys.length;
-        for (let i = 0; i < len; i++) {
-            const atrrName = keys[i];
-            obj[atrrName] = attrMap[atrrName];
-        }
-    }
-}
-function isLeafTag(obj) {
-    const propCount = Object.keys(obj).length;
-    if (propCount === 0) {
-        return true;
-    }
-    return false;
-}
-
-class XMLParser {
-    constructor(options) {
-        this.options = Object.assign({}, XMLParser.defaultOptions, options);
-    }
-    valid(xml) {
-        return xml.startsWith('<');
-    }
-    parse(xmlData) {
-        if (!this.valid) {
-            return false;
-        }
-        const orderedObjParser = new OrderedObjParser(this.options);
-        const orderedResult = orderedObjParser.parseXml(xmlData);
-        return prettify(orderedResult, this.options);
-    }
-}
-XMLParser.defaultOptions = {};
 function isSvg(str) {
     return str.startsWith('<svg') || str.startsWith('<?xml');
 }
@@ -6294,6 +5991,7 @@ function isXML(str) {
     return str.startsWith('<');
 }
 
+const loadXMLParser$1 = () => require('../common/xml/parser');
 function incrementalAddTo(group, graphic) {
     group.incrementalAppendChild(graphic);
 }
@@ -6406,6 +6104,7 @@ function xul(str) {
     }
     const valid = isXML(xmlStr);
     if (valid === true) {
+        const { XMLParser } = loadXMLParser$1();
         const parser = new XMLParser();
         const data = parser.parse(xmlStr);
         data.tc &&
@@ -9736,6 +9435,7 @@ function flushStageSharedStateRefresh(stage) {
 
 const _tempBounds$1 = new AABBBounds();
 const loadShadowRootFactory = () => require('./shadow-root');
+const loadXMLParser = () => require('../common/xml/parser');
 const tempMatrix = new Matrix();
 const PURE_STYLE_KEY = [
     'stroke',
@@ -10599,6 +10299,7 @@ class Graphic extends Node {
         symbolType = _symbolType || symbolType;
         const valid = isSvg(symbolType);
         if (valid === true) {
+            const { XMLParser } = loadXMLParser();
             const parser = new XMLParser();
             const { svg } = parser.parse(symbolType);
             if (!svg) {
@@ -17087,15 +16788,6 @@ class DefaultGraphicService {
             this.hooks.clearAABBBounds.call(graphic, stage, b);
         }
     }
-    updatePathProxyAABBBounds(aabbBounds, graphic) {
-        const path = typeof graphic.pathProxy === 'function' ? graphic.pathProxy(graphic.attribute) : graphic.pathProxy;
-        if (!path) {
-            return false;
-        }
-        const boundsContext = new BoundsContext(aabbBounds);
-        renderCommandList(path.commandList, boundsContext, 0, 0);
-        return true;
-    }
     updateHTMLTextAABBBounds(attribute, textTheme, aabbBounds, graphic) {
         const { textAlign, textBaseline } = attribute;
         if (attribute.forceBoundsHeight != null) {
@@ -28726,111 +28418,415 @@ class DefaultCircleAllocate extends DefaultGraphicAllocate {
         if (!this.pools.length) {
             return application.graphicService.creator.circle(area.attribute);
         }
-        const g = this.pools.pop();
-        g.initAttributes(area.attribute);
-        return g;
+        const g = this.pools.pop();
+        g.initAttributes(area.attribute);
+        return g;
+    }
+}
+const defaultCircleAllocate = new DefaultCircleAllocate();
+class DefaultLineAllocate extends DefaultGraphicAllocate {
+    allocate(attribute) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.line(attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(attribute);
+        return g;
+    }
+    allocateByObj(line) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.line(line.attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(line.attribute);
+        return g;
+    }
+}
+const defaultLineAllocate = new DefaultLineAllocate();
+class DefaultPathAllocate extends DefaultGraphicAllocate {
+    allocate(attribute) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.path(attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(attribute);
+        return g;
+    }
+    allocateByObj(path) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.path(path.attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(path.attribute);
+        return g;
+    }
+}
+const defaultPathAllocate = new DefaultPathAllocate();
+class DefaultSymbolAllocate extends DefaultGraphicAllocate {
+    allocate(attribute) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.symbol(attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(attribute);
+        return g;
+    }
+    allocateByObj(symbol) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.symbol(symbol.attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(symbol.attribute);
+        return g;
+    }
+}
+const defaultSymbolAllocate = new DefaultSymbolAllocate();
+class DefaultTextAllocate extends DefaultGraphicAllocate {
+    allocate(attribute) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.text(attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(attribute);
+        return g;
+    }
+    allocateByObj(text) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.text(text.attribute);
+        }
+        const g = this.pools.pop();
+        g.initAttributes(text.attribute);
+        return g;
+    }
+}
+const defaultTextAllocate = new DefaultTextAllocate();
+class DefaultGraphicMemoryManager {
+    constructor() {
+        this.map = {
+            text: defaultTextAllocate,
+            symbol: defaultSymbolAllocate
+        };
+    }
+    gc(g) {
+        if (g.isContainer) {
+            g.forEachChildren(i => this.gc(i));
+        }
+        else {
+            this.gcItem(g);
+        }
+    }
+    gcItem(g) {
+        const allocate = this.map[g.type];
+        if (allocate) {
+            allocate.free(g);
+        }
+    }
+}
+const defaultGraphicMemoryManager = new DefaultGraphicMemoryManager();
+
+function getAllMatches(string, regex) {
+    const matches = [];
+    let match = regex.exec(string);
+    while (match) {
+        const allmatches = [];
+        allmatches.startIndex = regex.lastIndex - match[0].length;
+        const len = match.length;
+        for (let index = 0; index < len; index++) {
+            allmatches.push(match[index]);
+        }
+        matches.push(allmatches);
+        match = regex.exec(string);
+    }
+    return matches;
+}
+
+class XmlNode {
+    constructor(tagname) {
+        this.tagname = tagname;
+        this.child = [];
+        this[':@'] = {};
+    }
+    add(key, val) {
+        if (key === '__proto__') {
+            key = '#__proto__';
+        }
+        this.child.push({ [key]: val });
+    }
+    addChild(node) {
+        if (node.tagname === '__proto__') {
+            node.tagname = '#__proto__';
+        }
+        if (node[':@'] && Object.keys(node[':@']).length > 0) {
+            this.child.push({ [node.tagname]: node.child, [':@']: node[':@'] });
+        }
+        else {
+            this.child.push({ [node.tagname]: node.child });
+        }
+    }
+}
+function findClosingIndex(xmlData, str, i, errMsg) {
+    const closingIndex = xmlData.indexOf(str, i);
+    if (closingIndex === -1) {
+        throw new Error(errMsg);
+    }
+    else {
+        return closingIndex + str.length - 1;
+    }
+}
+function tagExpWithClosingIndex(xmlData, i, closingChar = '>') {
+    let attrBoundary;
+    let tagExp = '';
+    for (let index = i; index < xmlData.length; index++) {
+        let ch = xmlData[index];
+        if (attrBoundary) {
+            if (ch === attrBoundary) {
+                attrBoundary = '';
+            }
+        }
+        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 readTagExp(xmlData, i, removeNSPrefix, closingChar = '>') {
+    const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
+    if (!result) {
+        return;
+    }
+    let tagExp = result.data;
+    const closeIndex = result.index;
+    const separatorIndex = tagExp.search(/\s/);
+    let tagName = tagExp;
+    let attrExpPresent = true;
+    if (separatorIndex !== -1) {
+        tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
+        tagExp = tagExp.substr(separatorIndex + 1);
+    }
+    const rawTagName = tagName;
+    if (removeNSPrefix) {
+        const 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,
+        rawTagName: rawTagName
+    };
 }
-const defaultCircleAllocate = new DefaultCircleAllocate();
-class DefaultLineAllocate extends DefaultGraphicAllocate {
-    allocate(attribute) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.line(attribute);
-        }
-        const g = this.pools.pop();
-        g.initAttributes(attribute);
-        return g;
+const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
+class OrderedObjParser {
+    constructor(options) {
+        this.currentNode = null;
+        this.options = options;
+        this.tagsNodeStack = [];
+        this.docTypeEntities = {};
     }
-    allocateByObj(line) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.line(line.attribute);
+    addChild(currentNode, childNode, jPath) {
+        const result = childNode.tagname;
+        if (typeof result === 'string') {
+            childNode.tagname = result;
+            currentNode.addChild(childNode);
+        }
+        else {
+            currentNode.addChild(childNode);
         }
-        const g = this.pools.pop();
-        g.initAttributes(line.attribute);
-        return g;
     }
-}
-const defaultLineAllocate = new DefaultLineAllocate();
-class DefaultPathAllocate extends DefaultGraphicAllocate {
-    allocate(attribute) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.path(attribute);
+    buildAttributesMap(attrStr, jPath, tagName) {
+        const attrs = {};
+        if (!attrStr) {
+            return;
         }
-        const g = this.pools.pop();
-        g.initAttributes(attribute);
-        return g;
+        const matches = getAllMatches(attrStr, attrsRegx);
+        const len = matches.length;
+        for (let i = 0; i < len; i++) {
+            const attrName = matches[i][1];
+            const oldVal = matches[i][4];
+            const aName = attrName;
+            if (attrName) {
+                if (oldVal !== undefined) {
+                    attrs[aName] = isNaN(oldVal) ? oldVal : Number(oldVal);
+                }
+                else {
+                    attrs[aName] = true;
+                }
+            }
+        }
+        return attrs;
     }
-    allocateByObj(path) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.path(path.attribute);
+    parseXml(xmlData) {
+        xmlData = xmlData.replace(/\r\n?/g, '\n');
+        const xmlObj = new XmlNode('!xml');
+        let currentNode = xmlObj;
+        let textData = '';
+        let jPath = '';
+        for (let i = 0; i < xmlData.length; i++) {
+            const ch = xmlData[i];
+            if (ch === '<') {
+                if (xmlData[i + 1] === '/') {
+                    const closeIndex = findClosingIndex(xmlData, '>', i, 'Closing Tag is not closed.');
+                    const propIndex = jPath.lastIndexOf('.');
+                    jPath = jPath.substring(0, propIndex);
+                    currentNode = this.tagsNodeStack.pop();
+                    if (currentNode && currentNode.child && textData) {
+                        currentNode.child[currentNode.child.length - 1][':@'] &&
+                            (currentNode.child[currentNode.child.length - 1][':@'].text = textData);
+                    }
+                    textData = '';
+                    i = closeIndex;
+                }
+                else if (xmlData[i + 1] === '?') {
+                    const tagData = readTagExp(xmlData, i, false, '?>');
+                    i = tagData.closeIndex + 1;
+                }
+                else if (xmlData.substr(i + 1, 3) === '!--') {
+                    const endIndex = findClosingIndex(xmlData, '-->', i + 4, 'Comment is not closed.');
+                    i = endIndex;
+                }
+                else {
+                    const result = readTagExp(xmlData, i, false);
+                    let tagName = result.tagName;
+                    let tagExp = result.tagExp;
+                    const attrExpPresent = result.attrExpPresent;
+                    const closeIndex = result.closeIndex;
+                    if (tagName !== xmlObj.tagname) {
+                        jPath += jPath ? '.' + tagName : tagName;
+                    }
+                    if (tagExp.length > 0 && tagExp.lastIndexOf('/') === tagExp.length - 1) {
+                        if (tagName[tagName.length - 1] === '/') {
+                            tagName = tagName.substr(0, tagName.length - 1);
+                            jPath = jPath.substr(0, jPath.length - 1);
+                            tagExp = tagName;
+                        }
+                        else {
+                            tagExp = tagExp.substr(0, tagExp.length - 1);
+                        }
+                        const childNode = new XmlNode(tagName);
+                        if (tagName !== tagExp && attrExpPresent) {
+                            childNode[':@'] = this.buildAttributesMap(tagExp, jPath, tagName);
+                        }
+                        this.addChild(currentNode, childNode, jPath);
+                        jPath = jPath.substr(0, jPath.lastIndexOf('.'));
+                    }
+                    else {
+                        const childNode = new XmlNode(tagName);
+                        this.tagsNodeStack.push(currentNode);
+                        if (tagName !== tagExp && attrExpPresent) {
+                            childNode[':@'] = this.buildAttributesMap(tagExp, jPath, tagName);
+                        }
+                        this.addChild(currentNode, childNode, jPath);
+                        currentNode = childNode;
+                    }
+                    textData = '';
+                    i = closeIndex;
+                }
+            }
+            else {
+                textData += xmlData[i];
+            }
         }
-        const g = this.pools.pop();
-        g.initAttributes(path.attribute);
-        return g;
+        return xmlObj.child;
     }
 }
-const defaultPathAllocate = new DefaultPathAllocate();
-class DefaultSymbolAllocate extends DefaultGraphicAllocate {
-    allocate(attribute) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.symbol(attribute);
+
+function prettify(node, options) {
+    return compress(node);
+}
+function compress(arr, jPath) {
+    const compressedObj = {};
+    for (let i = 0; i < arr.length; i++) {
+        const tagObj = arr[i];
+        const property = propName(tagObj);
+        if (property === undefined) {
+            continue;
         }
-        const g = this.pools.pop();
-        g.initAttributes(attribute);
-        return g;
-    }
-    allocateByObj(symbol) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.symbol(symbol.attribute);
+        else if (tagObj[property]) {
+            const val = compress(tagObj[property]);
+            isLeafTag(val);
+            if (tagObj[':@']) {
+                assignAttributes(val, tagObj[':@']);
+            }
+            if (compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
+                if (!Array.isArray(compressedObj[property])) {
+                    compressedObj[property] = [compressedObj[property]];
+                }
+                compressedObj[property].push(val);
+            }
+            else {
+                compressedObj[property] = val;
+            }
         }
-        const g = this.pools.pop();
-        g.initAttributes(symbol.attribute);
-        return g;
     }
+    return compressedObj;
 }
-const defaultSymbolAllocate = new DefaultSymbolAllocate();
-class DefaultTextAllocate extends DefaultGraphicAllocate {
-    allocate(attribute) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.text(attribute);
+function propName(obj) {
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (key !== ':@') {
+            return key;
         }
-        const g = this.pools.pop();
-        g.initAttributes(attribute);
-        return g;
     }
-    allocateByObj(text) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.text(text.attribute);
+}
+function assignAttributes(obj, attrMap, jpath) {
+    if (attrMap) {
+        const keys = Object.keys(attrMap);
+        const len = keys.length;
+        for (let i = 0; i < len; i++) {
+            const atrrName = keys[i];
+            obj[atrrName] = attrMap[atrrName];
         }
-        const g = this.pools.pop();
-        g.initAttributes(text.attribute);
-        return g;
     }
 }
-const defaultTextAllocate = new DefaultTextAllocate();
-class DefaultGraphicMemoryManager {
-    constructor() {
-        this.map = {
-            text: defaultTextAllocate,
-            symbol: defaultSymbolAllocate
-        };
+function isLeafTag(obj) {
+    const propCount = Object.keys(obj).length;
+    if (propCount === 0) {
+        return true;
     }
-    gc(g) {
-        if (g.isContainer) {
-            g.forEachChildren(i => this.gc(i));
-        }
-        else {
-            this.gcItem(g);
-        }
+    return false;
+}
+
+class XMLParser {
+    constructor(options) {
+        this.options = Object.assign({}, XMLParser.defaultOptions, options);
     }
-    gcItem(g) {
-        const allocate = this.map[g.type];
-        if (allocate) {
-            allocate.free(g);
+    valid(xml) {
+        return xml.startsWith('<');
+    }
+    parse(xmlData) {
+        if (!this.valid) {
+            return false;
         }
+        const orderedObjParser = new OrderedObjParser(this.options);
+        const orderedResult = orderedObjParser.parseXml(xmlData);
+        return prettify(orderedResult, this.options);
     }
 }
-const defaultGraphicMemoryManager = new DefaultGraphicMemoryManager();
+XMLParser.defaultOptions = {};
 
 function describeServiceIdentifier(serviceIdentifier) {
     if (typeof serviceIdentifier === 'string') {