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

package/dist/index.es.js

@@ -5984,6 +5984,292 @@ 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;
+}
+
 function isSvg(str) {
     return str.startsWith('<svg') || str.startsWith('<?xml');
 }
@@ -5991,7 +6277,24 @@ function isXML(str) {
     return str.startsWith('<');
 }
 
-const loadXMLParser$1 = () => require('../common/xml/parser');
+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 incrementalAddTo(group, graphic) {
     group.incrementalAppendChild(graphic);
 }
@@ -6104,7 +6407,6 @@ 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 &&
@@ -9435,7 +9737,6 @@ 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',
@@ -10299,7 +10600,6 @@ 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) {
@@ -28410,423 +28710,119 @@ class DefaultCircleAllocate extends DefaultGraphicAllocate {
         if (!this.pools.length) {
             return application.graphicService.creator.circle(attribute);
         }
-        const g = this.pools.pop();
-        g.initAttributes(attribute);
-        return g;
-    }
-    allocateByObj(area) {
-        if (!this.pools.length) {
-            return application.graphicService.creator.circle(area.attribute);
-        }
-        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 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);
-        }
+        const g = this.pools.pop();
+        g.initAttributes(attribute);
+        return g;
     }
-    buildAttributesMap(attrStr, jPath, tagName) {
-        const attrs = {};
-        if (!attrStr) {
-            return;
+    allocateByObj(area) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.circle(area.attribute);
         }
-        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;
-                }
-            }
+        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);
         }
-        return attrs;
+        const g = this.pools.pop();
+        g.initAttributes(attribute);
+        return g;
     }
-    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];
-            }
+    allocateByObj(line) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.line(line.attribute);
         }
-        return xmlObj.child;
+        const g = this.pools.pop();
+        g.initAttributes(line.attribute);
+        return g;
     }
 }
-
-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 defaultLineAllocate = new DefaultLineAllocate();
+class DefaultPathAllocate extends DefaultGraphicAllocate {
+    allocate(attribute) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.path(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(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;
     }
-    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;
+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;
     }
-}
-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];
+    allocateByObj(symbol) {
+        if (!this.pools.length) {
+            return application.graphicService.creator.symbol(symbol.attribute);
         }
+        const g = this.pools.pop();
+        g.initAttributes(symbol.attribute);
+        return g;
     }
 }
-function isLeafTag(obj) {
-    const propCount = Object.keys(obj).length;
-    if (propCount === 0) {
-        return true;
+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;
     }
-    return false;
 }
-
-class XMLParser {
-    constructor(options) {
-        this.options = Object.assign({}, XMLParser.defaultOptions, options);
+const defaultTextAllocate = new DefaultTextAllocate();
+class DefaultGraphicMemoryManager {
+    constructor() {
+        this.map = {
+            text: defaultTextAllocate,
+            symbol: defaultSymbolAllocate
+        };
     }
-    valid(xml) {
-        return xml.startsWith('<');
+    gc(g) {
+        if (g.isContainer) {
+            g.forEachChildren(i => this.gc(i));
+        }
+        else {
+            this.gcItem(g);
+        }
     }
-    parse(xmlData) {
-        if (!this.valid) {
-            return false;
+    gcItem(g) {
+        const allocate = this.map[g.type];
+        if (allocate) {
+            allocate.free(g);
         }
-        const orderedObjParser = new OrderedObjParser(this.options);
-        const orderedResult = orderedObjParser.parseXml(xmlData);
-        return prettify(orderedResult, this.options);
     }
 }
-XMLParser.defaultOptions = {};
+const defaultGraphicMemoryManager = new DefaultGraphicMemoryManager();
 
 function describeServiceIdentifier(serviceIdentifier) {
     if (typeof serviceIdentifier === 'string') {
@@ -28864,8 +28860,10 @@ function bindArcRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedArcModuleContexts, bind)) {
         return;
     }
-    bind(DefaultCanvasArcRender).toSelf().inSingletonScope();
-    bind(ArcRender).to(DefaultCanvasArcRender).inSingletonScope();
+    bind(DefaultCanvasArcRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasArcRender(createContributionProvider(ArcRenderContribution, container)))
+        .inSingletonScope();
+    bind(ArcRender).toService(DefaultCanvasArcRender);
     bind(GraphicRender).toService(ArcRender);
     bind(ArcRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, ArcRenderContribution);
@@ -28896,9 +28894,10 @@ function bindLineRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedLineModuleContexts, bind)) {
         return;
     }
-    bind(DefaultCanvasLineRender).toSelf().inSingletonScope();
-    bind(DefaultIncrementalCanvasLineRender).toSelf().inSingletonScope();
-    bind(LineRender).to(DefaultCanvasLineRender).inSingletonScope();
+    bind(DefaultCanvasLineRender)
+        .toDynamicValue(() => new DefaultCanvasLineRender())
+        .inSingletonScope();
+    bind(LineRender).toService(DefaultCanvasLineRender);
     bind(GraphicRender).toService(LineRender);
 }
 const lineModule = bindLineRenderModule;
@@ -28908,12 +28907,13 @@ function bindAreaRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedAreaModuleContexts, bind)) {
         return;
     }
-    bind(DefaultCanvasAreaRender).toSelf().inSingletonScope();
-    bind(AreaRender).to(DefaultCanvasAreaRender).inSingletonScope();
+    bind(DefaultCanvasAreaRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasAreaRender(createContributionProvider(AreaRenderContribution, container)))
+        .inSingletonScope();
+    bind(AreaRender).toService(DefaultCanvasAreaRender);
     bind(GraphicRender).toService(AreaRender);
     bind(AreaRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, AreaRenderContribution);
-    bind(DefaultIncrementalCanvasAreaRender).toSelf().inSingletonScope();
 }
 const areaModule = bindAreaRenderModule;
 
@@ -28922,8 +28922,10 @@ function bindSymbolRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedSymbolModuleContexts, bind)) {
         return;
     }
-    bind(DefaultCanvasSymbolRender).toSelf().inSingletonScope();
-    bind(SymbolRender).to(DefaultCanvasSymbolRender).inSingletonScope();
+    bind(DefaultCanvasSymbolRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasSymbolRender(createContributionProvider(SymbolRenderContribution, container)))
+        .inSingletonScope();
+    bind(SymbolRender).toService(DefaultCanvasSymbolRender);
     bind(GraphicRender).toService(SymbolRender);
     bind(SymbolRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, SymbolRenderContribution);
@@ -28935,8 +28937,10 @@ function bindCircleRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedCircleModuleContexts, bind)) {
         return;
     }
-    bind(DefaultCanvasCircleRender).toSelf().inSingletonScope();
-    bind(CircleRender).to(DefaultCanvasCircleRender).inSingletonScope();
+    bind(DefaultCanvasCircleRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasCircleRender(createContributionProvider(CircleRenderContribution, container)))
+        .inSingletonScope();
+    bind(CircleRender).toService(DefaultCanvasCircleRender);
     bind(GraphicRender).toService(CircleRender);
     bind(CircleRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, CircleRenderContribution);
@@ -28948,7 +28952,9 @@ function bindTextRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedTextModuleContexts, bind)) {
         return;
     }
-    bind(TextRender).to(DefaultCanvasTextRender).inSingletonScope();
+    bind(TextRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasTextRender(createContributionProvider(TextRenderContribution, container)))
+        .inSingletonScope();
     bind(GraphicRender).toService(TextRender);
     bind(TextRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, TextRenderContribution);
@@ -28960,8 +28966,10 @@ function bindPathRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedPathModuleContexts, bind)) {
         return;
     }
-    bind(DefaultCanvasPathRender).toSelf().inSingletonScope();
-    bind(PathRender).to(DefaultCanvasPathRender).inSingletonScope();
+    bind(DefaultCanvasPathRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasPathRender(createContributionProvider(PathRenderContribution, container)))
+        .inSingletonScope();
+    bind(PathRender).toService(DefaultCanvasPathRender);
     bind(GraphicRender).toService(PathRender);
     bind(PathRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, PathRenderContribution);
@@ -28973,7 +28981,9 @@ function bindPolygonRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedPolygonModuleContexts, bind)) {
         return;
     }
-    bind(PolygonRender).to(DefaultCanvasPolygonRender).inSingletonScope();
+    bind(PolygonRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasPolygonRender(createContributionProvider(PolygonRenderContribution, container)))
+        .inSingletonScope();
     bind(GraphicRender).toService(PolygonRender);
     bind(PolygonRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, PolygonRenderContribution);
@@ -28981,12 +28991,12 @@ function bindPolygonRenderModule({ bind }) {
 const polygonModule = bindPolygonRenderModule;
 
 class DefaultCanvasStarRender extends BaseRender {
-    constructor(starRenderContribitions) {
+    constructor(graphicRenderContributions) {
         super();
-        this.starRenderContribitions = starRenderContribitions;
+        this.graphicRenderContributions = graphicRenderContributions;
         this.numberType = STAR_NUMBER_TYPE;
         this.builtinContributions = [defaultStarBackgroundRenderContribution, defaultStarTextureRenderContribution];
-        this.init(starRenderContribitions);
+        this.init(graphicRenderContributions);
     }
     drawShape(star, context, x, y, drawContext, params, fillCb, strokeCb) {
         const starAttribute = getTheme(star, params === null || params === void 0 ? void 0 : params.theme).star;
@@ -29059,6 +29069,7 @@ function bindStarRenderModule({ bind }) {
         .inSingletonScope();
     bind(StarRender).toService(DefaultCanvasStarRender);
     bind(GraphicRender).toService(StarRender);
+    bindContributionProvider(bind, StarRenderContribution);
 }
 const starModule = bindStarRenderModule;
 
@@ -29104,7 +29115,10 @@ function bindGlyphRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedGlyphModuleContexts, bind)) {
         return;
     }
-    bind(GlyphRender).to(DefaultCanvasGlyphRender).inSingletonScope();
+    bind(DefaultCanvasGlyphRender)
+        .toDynamicValue(() => new DefaultCanvasGlyphRender())
+        .inSingletonScope();
+    bind(GlyphRender).toService(DefaultCanvasGlyphRender);
     bind(GraphicRender).toService(GlyphRender);
 }
 const glyphModule = bindGlyphRenderModule;
@@ -29183,7 +29197,10 @@ function bindRichtextRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedRichtextModuleContexts, bind)) {
         return;
     }
-    bind(RichTextRender).to(DefaultCanvasRichTextRender).inSingletonScope();
+    bind(DefaultCanvasRichTextRender)
+        .toDynamicValue(() => new DefaultCanvasRichTextRender())
+        .inSingletonScope();
+    bind(RichTextRender).toService(DefaultCanvasRichTextRender);
     bind(GraphicRender).toService(RichTextRender);
 }
 const richtextModule = bindRichtextRenderModule;
@@ -29193,7 +29210,9 @@ function bindImageRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedImageModuleContexts, bind)) {
         return;
     }
-    bind(ImageRender).to(DefaultCanvasImageRender).inSingletonScope();
+    bind(ImageRender)
+        .toDynamicValue(({ container }) => new DefaultCanvasImageRender(createContributionProvider(ImageRenderContribution, container)))
+        .inSingletonScope();
     bind(GraphicRender).toService(ImageRender);
     bind(ImageRenderContribution).toService(DefaultBaseInteractiveRenderContribution);
     bindContributionProvider(bind, ImageRenderContribution);
@@ -29341,7 +29360,10 @@ function bindRect3dRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedRect3dModuleContexts, bind)) {
         return;
     }
-    bind(Rect3DRender).to(DefaultCanvasRect3dRender).inSingletonScope();
+    bind(DefaultCanvasRect3dRender)
+        .toDynamicValue(() => new DefaultCanvasRect3dRender())
+        .inSingletonScope();
+    bind(Rect3DRender).toService(DefaultCanvasRect3dRender);
     bind(GraphicRender).toService(Rect3DRender);
 }
 const rect3dModule = bindRect3dRenderModule;
@@ -29540,7 +29562,10 @@ function bindArc3dRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedArc3dModuleContexts, bind)) {
         return;
     }
-    bind(Arc3dRender).to(DefaultCanvasArc3DRender).inSingletonScope();
+    bind(DefaultCanvasArc3DRender)
+        .toDynamicValue(() => new DefaultCanvasArc3DRender())
+        .inSingletonScope();
+    bind(Arc3dRender).toService(DefaultCanvasArc3DRender);
     bind(GraphicRender).toService(Arc3dRender);
 }
 const arc3dModule = bindArc3dRenderModule;
@@ -29586,7 +29611,10 @@ function bindPyramid3dRenderModule({ bind }) {
     if (isBindingContextLoaded(loadedPyramid3dModuleContexts, bind)) {
         return;
     }
-    bind(Pyramid3dRender).to(DefaultCanvasPyramid3dRender).inSingletonScope();
+    bind(DefaultCanvasPyramid3dRender)
+        .toDynamicValue(() => new DefaultCanvasPyramid3dRender())
+        .inSingletonScope();
+    bind(Pyramid3dRender).toService(DefaultCanvasPyramid3dRender);
     bind(GraphicRender).toService(Pyramid3dRender);
 }
 const pyramid3dModule = bindPyramid3dRenderModule;