@visactor/vrender-core 1.1.0-alpha.24 → 1.1.0-alpha.26

package/dist/index.es.js

@@ -698,6 +698,9 @@ class Node extends EventEmitter {
         this.parent = null;
         this._count = 1;
     }
+    onParentSharedStateTreeChanged(_stage, _layer) {
+        return;
+    }
     forEachChildren(cb, reverse = false) {
         if (reverse) {
             let child = this._lastChild;
@@ -5981,439 +5984,138 @@ 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;
+function isSvg(str) {
+    return str.startsWith('<svg') || str.startsWith('<?xml');
 }
-
-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 isXML(str) {
+    return str.startsWith('<');
 }
-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;
-    }
+
+const loadXMLParser$1 = () => require('../common/xml/parser');
+function incrementalAddTo(group, graphic) {
+    group.incrementalAppendChild(graphic);
 }
-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 = '';
+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);
+            });
+        });
+        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);
+                            });
+                        }));
+                    }
+                });
             }
-        }
-        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
-                    };
-                }
+        });
+        yield Promise.all(promiseList);
+    });
+}
+function boundStroke(bounds, halfW, miter, pad = 0) {
+    bounds.expand(halfW + (pad / 2 + (miter ? miterAdjustment(miter, halfW) : 0)));
+    return bounds;
+}
+function miterAdjustment(miter, strokeWidth) {
+    return miter ? strokeWidth : 0;
+}
+let NUMBER_TYPE = 0;
+function genNumberType() {
+    return NUMBER_TYPE++;
+}
+var TextDirection;
+(function (TextDirection) {
+    TextDirection[TextDirection["HORIZONTAL"] = 0] = "HORIZONTAL";
+    TextDirection[TextDirection["VERTICAL"] = 1] = "VERTICAL";
+})(TextDirection || (TextDirection = {}));
+function verticalLayout(text) {
+    const nextCharacter = [];
+    let flag = 0;
+    let currStr = '';
+    for (let i = 0; i < text.length; i++) {
+        if (rotateText(text[i])) {
+            if (flag) {
+                currStr += text[i];
             }
             else {
-                return {
-                    data: tagExp,
-                    index: index
-                };
+                flag = 1;
+                currStr = text[i];
             }
         }
-        else if (ch === '\t') {
-            ch = ' ';
+        else {
+            if (flag) {
+                nextCharacter.push({
+                    text: currStr,
+                    direction: TextDirection.VERTICAL
+                });
+                currStr = '';
+                flag = 0;
+            }
+            nextCharacter.push({
+                text: text[i],
+                direction: TextDirection.HORIZONTAL
+            });
         }
-        tagExp += ch;
     }
+    if (currStr) {
+        nextCharacter.push({
+            text: currStr,
+            direction: TextDirection.VERTICAL
+        });
+    }
+    return nextCharacter;
 }
-function readTagExp(xmlData, i, removeNSPrefix, closingChar = '>') {
-    const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
-    if (!result) {
-        return;
+const rotateCharList = ['…', '（', '）', '—', '【', '】', '「', '」', '《', '》'];
+const rotateCharMap = new Map();
+rotateCharList.forEach(c => rotateCharMap.set(c, true));
+const noRotateCharList = [''];
+const noRotateCharMap = new Map();
+noRotateCharList.forEach(c => noRotateCharMap.set(c, true));
+function rotateText(c) {
+    if (rotateCharMap.has(c)) {
+        return true;
     }
-    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);
+    if (noRotateCharMap.has(c)) {
+        return false;
     }
-    const rawTagName = tagName;
-    if (removeNSPrefix) {
-        const colonIndex = tagName.indexOf(':');
-        if (colonIndex !== -1) {
-            tagName = tagName.substr(colonIndex + 1);
-            attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
-        }
+    const cp = c.codePointAt(0);
+    let rotate = false;
+    if (cp < 256) {
+        rotate = true;
     }
-    return {
-        tagName: tagName,
-        tagExp: tagExp,
-        closeIndex: closeIndex,
-        attrExpPresent: attrExpPresent,
-        rawTagName: rawTagName
-    };
+    return rotate;
 }
-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);
-        }
+function xul(str) {
+    const xmlStr = isArray(str) ? str[0] : str;
+    const config = [];
+    if (!xmlStr) {
+        return config;
     }
-    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);
+    const valid = isXML(xmlStr);
+    if (valid === true) {
+        const { XMLParser } = loadXMLParser$1();
+        const parser = new XMLParser();
+        const data = parser.parse(xmlStr);
+        data.tc &&
+            Object.keys(data.tc).forEach(k => {
+                if (k === 'text') {
+                    config.push(parseRTTextXML(data.tc[k]));
                 }
                 else {
-                    attrs[aName] = true;
+                    config.push(parseRTImageXML(data.tc[k]));
                 }
-            }
-        }
-        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');
-}
-function isXML(str) {
-    return str.startsWith('<');
-}
-
-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);
-            });
-        });
-        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);
-                            });
-                        }));
-                    }
-                });
-            }
-        });
-        yield Promise.all(promiseList);
-    });
-}
-function boundStroke(bounds, halfW, miter, pad = 0) {
-    bounds.expand(halfW + (pad / 2 + (miter ? miterAdjustment(miter, halfW) : 0)));
-    return bounds;
-}
-function miterAdjustment(miter, strokeWidth) {
-    return miter ? strokeWidth : 0;
-}
-let NUMBER_TYPE = 0;
-function genNumberType() {
-    return NUMBER_TYPE++;
-}
-var TextDirection;
-(function (TextDirection) {
-    TextDirection[TextDirection["HORIZONTAL"] = 0] = "HORIZONTAL";
-    TextDirection[TextDirection["VERTICAL"] = 1] = "VERTICAL";
-})(TextDirection || (TextDirection = {}));
-function verticalLayout(text) {
-    const nextCharacter = [];
-    let flag = 0;
-    let currStr = '';
-    for (let i = 0; i < text.length; i++) {
-        if (rotateText(text[i])) {
-            if (flag) {
-                currStr += text[i];
-            }
-            else {
-                flag = 1;
-                currStr = text[i];
-            }
-        }
-        else {
-            if (flag) {
-                nextCharacter.push({
-                    text: currStr,
-                    direction: TextDirection.VERTICAL
-                });
-                currStr = '';
-                flag = 0;
-            }
-            nextCharacter.push({
-                text: text[i],
-                direction: TextDirection.HORIZONTAL
-            });
-        }
-    }
-    if (currStr) {
-        nextCharacter.push({
-            text: currStr,
-            direction: TextDirection.VERTICAL
-        });
-    }
-    return nextCharacter;
-}
-const rotateCharList = ['…', '（', '）', '—', '【', '】', '「', '」', '《', '》'];
-const rotateCharMap = new Map();
-rotateCharList.forEach(c => rotateCharMap.set(c, true));
-const noRotateCharList = [''];
-const noRotateCharMap = new Map();
-noRotateCharList.forEach(c => noRotateCharMap.set(c, true));
-function rotateText(c) {
-    if (rotateCharMap.has(c)) {
-        return true;
-    }
-    if (noRotateCharMap.has(c)) {
-        return false;
-    }
-    const cp = c.codePointAt(0);
-    let rotate = false;
-    if (cp < 256) {
-        rotate = true;
-    }
-    return rotate;
-}
-function xul(str) {
-    const xmlStr = isArray(str) ? str[0] : str;
-    const config = [];
-    if (!xmlStr) {
-        return config;
-    }
-    const valid = isXML(xmlStr);
-    if (valid === true) {
-        const parser = new XMLParser();
-        const data = parser.parse(xmlStr);
-        data.tc &&
-            Object.keys(data.tc).forEach(k => {
-                if (k === 'text') {
-                    config.push(parseRTTextXML(data.tc[k]));
-                }
-                else {
-                    config.push(parseRTImageXML(data.tc[k]));
-                }
-            });
+            });
     }
     return config;
 }
@@ -9024,7 +8726,7 @@ function createConicalGradient(context, stops, x, y, deltaAngle, startAngle, end
     return pattern;
 }
 
-const FULL_DEFINITION_KEYS$1 = new Set([
+const FULL_DEFINITION_KEYS = new Set([
     'name',
     'patch',
     'priority',
@@ -9033,7 +8735,7 @@ const FULL_DEFINITION_KEYS$1 = new Set([
     'resolver',
     'declaredAffectedKeys'
 ]);
-function isPlainObject$2(value) {
+function isPlainObject$1(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 function normalizePatch(value) {
@@ -9095,453 +8797,81 @@ class StateDefinitionCompiler {
                 patch: undefined
             };
         }
-        const keys = isPlainObject$2(value) ? Object.keys(value) : [];
-        const hasFullKey = keys.some(key => FULL_DEFINITION_KEYS$1.has(key));
+        const keys = isPlainObject$1(value) ? Object.keys(value) : [];
+        const hasFullKey = keys.some(key => FULL_DEFINITION_KEYS.has(key));
         if (hasFullKey) {
             const definition = value;
             return {
                 name: (_a = definition.name) !== null && _a !== void 0 ? _a : name,
                 priority: (_b = definition.priority) !== null && _b !== void 0 ? _b : 0,
-                rank: definition.rank,
                 patch: normalizePatch(definition.patch),
                 resolver: definition.resolver,
                 declaredAffectedKeys: definition.declaredAffectedKeys,
-                exclude: definition.exclude,
-                suppress: definition.suppress
-            };
-        }
-        return {
-            name,
-            priority: 0,
-            patch: value
-        };
-    }
-    expandRelationClosure(compiled, relation) {
-        const rawRelationMap = new Map();
-        compiled.forEach((definition, name) => {
-            rawRelationMap.set(name, new Set(definition[relation]));
-        });
-        compiled.forEach((definition, origin) => {
-            const closure = new Set();
-            const walk = (stateName, stack) => {
-                const nextStates = rawRelationMap.get(stateName);
-                if (!nextStates || !nextStates.size) {
-                    return;
-                }
-                nextStates.forEach(nextState => {
-                    if (nextState === origin) {
-                        console.warn(`[StateDefinitionCompiler] circular ${relation} relation detected: ${stack.join(' -> ')} -> ${origin}`);
-                        return;
-                    }
-                    if (stack.includes(nextState)) {
-                        console.warn(`[StateDefinitionCompiler] circular ${relation} relation detected: ${stack.join(' -> ')} -> ${nextState}`);
-                        return;
-                    }
-                    if (closure.has(nextState)) {
-                        return;
-                    }
-                    closure.add(nextState);
-                    walk(nextState, stack.concat(nextState));
-                });
-            };
-            walk(origin, [origin]);
-            definition[relation] = closure;
-        });
-    }
-}
-
-var UpdateCategory;
-(function (UpdateCategory) {
-    UpdateCategory[UpdateCategory["NONE"] = 0] = "NONE";
-    UpdateCategory[UpdateCategory["PAINT"] = 1] = "PAINT";
-    UpdateCategory[UpdateCategory["SHAPE"] = 2] = "SHAPE";
-    UpdateCategory[UpdateCategory["BOUNDS"] = 4] = "BOUNDS";
-    UpdateCategory[UpdateCategory["TRANSFORM"] = 8] = "TRANSFORM";
-    UpdateCategory[UpdateCategory["LAYOUT"] = 16] = "LAYOUT";
-    UpdateCategory[UpdateCategory["PICK"] = 32] = "PICK";
-})(UpdateCategory || (UpdateCategory = {}));
-const ATTRIBUTE_CATEGORY = {
-    fill: UpdateCategory.PAINT,
-    opacity: UpdateCategory.PAINT,
-    fillOpacity: UpdateCategory.PAINT,
-    strokeOpacity: UpdateCategory.PAINT,
-    lineDash: UpdateCategory.PAINT,
-    lineDashOffset: UpdateCategory.PAINT,
-    lineCap: UpdateCategory.PAINT,
-    lineJoin: UpdateCategory.PAINT,
-    miterLimit: UpdateCategory.PAINT,
-    shadowColor: UpdateCategory.PAINT,
-    x: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    y: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    scaleX: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    scaleY: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    angle: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    anchor: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    anchor3d: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    postMatrix: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
-    layout: UpdateCategory.LAYOUT,
-    zIndex: UpdateCategory.PAINT,
-    visible: UpdateCategory.PAINT | UpdateCategory.PICK,
-    lineWidth: UpdateCategory.SHAPE | UpdateCategory.BOUNDS | UpdateCategory.PICK,
-    width: UpdateCategory.SHAPE | UpdateCategory.BOUNDS,
-    height: UpdateCategory.SHAPE | UpdateCategory.BOUNDS
-};
-const ATTRIBUTE_DELTA_CLASSIFIER = {
-    stroke: (prev, next) => {
-        const prevEnabled = prev != null && prev !== false;
-        const nextEnabled = next != null && next !== false;
-        if (prevEnabled !== nextEnabled) {
-            return UpdateCategory.PAINT | UpdateCategory.BOUNDS | UpdateCategory.PICK;
-        }
-        return UpdateCategory.PAINT;
-    },
-    shadowBlur: (prev, next) => {
-        const prevBlur = Number(prev !== null && prev !== void 0 ? prev : 0);
-        const nextBlur = Number(next !== null && next !== void 0 ? next : 0);
-        if (prevBlur !== nextBlur && (prevBlur > 0 || nextBlur > 0)) {
-            return UpdateCategory.PAINT | UpdateCategory.BOUNDS;
-        }
-        return UpdateCategory.PAINT;
-    }
-};
-function classifyAttributeDelta(key, prev, next) {
-    var _a;
-    const dynamicClassifier = ATTRIBUTE_DELTA_CLASSIFIER[key];
-    if (dynamicClassifier) {
-        return dynamicClassifier(prev, next);
-    }
-    return (_a = ATTRIBUTE_CATEGORY[key]) !== null && _a !== void 0 ? _a : UpdateCategory.PAINT;
-}
-function classifyAffectedKeyConservatively(key) {
-    var _a;
-    if (key === 'stroke') {
-        return UpdateCategory.PAINT | UpdateCategory.BOUNDS | UpdateCategory.PICK;
-    }
-    if (key === 'shadowBlur') {
-        return UpdateCategory.PAINT | UpdateCategory.BOUNDS;
-    }
-    return (_a = ATTRIBUTE_CATEGORY[key]) !== null && _a !== void 0 ? _a : UpdateCategory.PAINT;
-}
-function classifyAffectedKeys(keys) {
-    let category = UpdateCategory.NONE;
-    for (const key of keys) {
-        category |= classifyAffectedKeyConservatively(key);
-    }
-    return category;
-}
-
-const DEFAULT_MAX_EVENT_RECORDS = 100;
-const STAGE_PERF_MONITOR = Symbol('vrender.statePerfMonitor');
-function createReasonBreakdown() {
-    return {
-        config_disabled: 0,
-        context_disabled: 0,
-        non_batch_operation: 0,
-        mixed_update_category: 0,
-        resolver_unstable_keys: 0,
-        graphic_unavailable: 0
-    };
-}
-function createEmptyStatePerfSnapshot() {
-    return {
-        counters: {
-            stateCommits: 0,
-            sharedRefreshCommits: 0,
-            deferredJobsCreated: 0,
-            deferredJobsCompleted: 0,
-            deferredJobsCancelled: 0,
-            deferredJobsCoalesced: 0,
-            deferredGraphicsCommitted: 0,
-            deferredBudgetYields: 0,
-            deferredIneligibleGraphics: 0
-        },
-        deferredIneligibleByReason: createReasonBreakdown(),
-        categoryBreakdown: {
-            paint: 0,
-            transform: 0,
-            shape: 0,
-            bounds: 0,
-            layout: 0,
-            pick: 0
-        },
-        refresh: {
-            queuedGraphics: 0,
-            flushedGraphics: 0,
-            ensureFreshCalls: 0,
-            renderScheduled: 0
-        },
-        resolver: {
-            cacheHits: 0,
-            cacheMisses: 0,
-            invalidations: 0
-        },
-        cost: {
-            resolverTotalMs: 0,
-            resolverMaxMs: 0,
-            patchTotalMs: 0,
-            patchMaxMs: 0,
-            sharedRefreshTotalMs: 0,
-            sharedRefreshMaxMs: 0,
-            batchSliceTotalMs: 0,
-            batchSliceMaxMs: 0
-        },
-        allocationHints: {
-            patchObjectsCreated: 0,
-            batchEntriesCreated: 0,
-            refreshQueuePushes: 0
-        },
-        batch: {
-            pendingJobs: 0,
-            maxPendingJobs: 0,
-            maxGraphicsInJob: 0,
-            maxFrameSliceCost: 0
-        },
-        events: []
-    };
-}
-function cloneSnapshot(snapshot) {
-    return {
-        counters: Object.assign({}, snapshot.counters),
-        deferredIneligibleByReason: Object.assign({}, snapshot.deferredIneligibleByReason),
-        categoryBreakdown: Object.assign({}, snapshot.categoryBreakdown),
-        refresh: Object.assign({}, snapshot.refresh),
-        resolver: Object.assign({}, snapshot.resolver),
-        cost: Object.assign({}, snapshot.cost),
-        allocationHints: Object.assign({}, snapshot.allocationHints),
-        batch: Object.assign({}, snapshot.batch),
-        events: snapshot.events ? snapshot.events.slice() : []
-    };
-}
-function isDeferredStateContextConfig(value) {
-    return (!!value &&
-        (Object.prototype.hasOwnProperty.call(value, 'deferred') ||
-            Object.prototype.hasOwnProperty.call(value, 'localEnabled')));
-}
-function normalizeDeferredStateOwnerConfig(value) {
-    if (!value) {
-        return undefined;
-    }
-    if (isDeferredStateContextConfig(value)) {
-        return value;
-    }
-    return {
-        deferred: value
-    };
-}
-function normalizeDeferredStateConfig(config) {
-    var _a, _b, _c;
-    return {
-        enabled: (_a = config === null || config === void 0 ? void 0 : config.enabled) !== null && _a !== void 0 ? _a : false,
-        frameBudget: (_b = config === null || config === void 0 ? void 0 : config.frameBudget) !== null && _b !== void 0 ? _b : 8,
-        maxGraphicsPerFrame: (_c = config === null || config === void 0 ? void 0 : config.maxGraphicsPerFrame) !== null && _c !== void 0 ? _c : 100
-    };
-}
-function fingerprintDeferredStateConfig(config) {
-    return `${config.enabled ? 1 : 0}:${config.frameBudget}:${config.maxGraphicsPerFrame}`;
-}
-class StatePerfMonitor {
-    constructor(configSource) {
-        this.configSource = configSource;
-        this.snapshot = createEmptyStatePerfSnapshot();
-    }
-    setConfig(config) {
-        this.configSource = config;
-    }
-    getSnapshot() {
-        return cloneSnapshot(this.snapshot);
-    }
-    reset() {
-        const next = createEmptyStatePerfSnapshot();
-        Object.assign(this.snapshot.counters, next.counters);
-        Object.assign(this.snapshot.deferredIneligibleByReason, next.deferredIneligibleByReason);
-        Object.assign(this.snapshot.categoryBreakdown, next.categoryBreakdown);
-        Object.assign(this.snapshot.refresh, next.refresh);
-        Object.assign(this.snapshot.resolver, next.resolver);
-        Object.assign(this.snapshot.cost, next.cost);
-        Object.assign(this.snapshot.allocationHints, next.allocationHints);
-        Object.assign(this.snapshot.batch, next.batch);
-        this.snapshot.events = [];
-    }
-    incrementCounter(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.counters[key] += delta;
-    }
-    recordDeferredIneligible(reason, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.deferredIneligibleByReason[reason] += delta;
-        this.snapshot.counters.deferredIneligibleGraphics += delta;
-        this.recordEvent('deferred-ineligible', { reason, count: delta });
-    }
-    recordCategory(category) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        if (category & UpdateCategory.PAINT) {
-            this.snapshot.categoryBreakdown.paint += 1;
-        }
-        if (category & UpdateCategory.TRANSFORM) {
-            this.snapshot.categoryBreakdown.transform += 1;
-        }
-        if (category & UpdateCategory.SHAPE) {
-            this.snapshot.categoryBreakdown.shape += 1;
-        }
-        if (category & UpdateCategory.BOUNDS) {
-            this.snapshot.categoryBreakdown.bounds += 1;
-        }
-        if (category & UpdateCategory.LAYOUT) {
-            this.snapshot.categoryBreakdown.layout += 1;
-        }
-        if (category & UpdateCategory.PICK) {
-            this.snapshot.categoryBreakdown.pick += 1;
-        }
-    }
-    recordRefresh(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.refresh[key] += delta;
-    }
-    recordResolver(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.resolver[key] += delta;
-    }
-    recordCost(kind, durationMs) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        if (kind === 'resolver') {
-            this.snapshot.cost.resolverTotalMs += durationMs;
-            this.snapshot.cost.resolverMaxMs = Math.max(this.snapshot.cost.resolverMaxMs, durationMs);
-            return;
-        }
-        if (kind === 'patch') {
-            this.snapshot.cost.patchTotalMs += durationMs;
-            this.snapshot.cost.patchMaxMs = Math.max(this.snapshot.cost.patchMaxMs, durationMs);
-            return;
-        }
-        if (kind === 'sharedRefresh') {
-            this.snapshot.cost.sharedRefreshTotalMs += durationMs;
-            this.snapshot.cost.sharedRefreshMaxMs = Math.max(this.snapshot.cost.sharedRefreshMaxMs, durationMs);
-            return;
-        }
-        this.snapshot.cost.batchSliceTotalMs += durationMs;
-        this.snapshot.cost.batchSliceMaxMs = Math.max(this.snapshot.cost.batchSliceMaxMs, durationMs);
-        this.snapshot.batch.maxFrameSliceCost = Math.max(this.snapshot.batch.maxFrameSliceCost, durationMs);
-    }
-    recordAllocation(key, delta = 1) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.allocationHints[key] += delta;
-    }
-    updateBatchPending(pendingJobs) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.batch.pendingJobs = pendingJobs;
-        this.snapshot.batch.maxPendingJobs = Math.max(this.snapshot.batch.maxPendingJobs, pendingJobs);
-    }
-    updateMaxGraphicsInJob(count) {
-        if (!this.isEnabled()) {
-            return;
-        }
-        this.snapshot.batch.maxGraphicsInJob = Math.max(this.snapshot.batch.maxGraphicsInJob, count);
-    }
-    recordEvent(type, detail) {
-        var _a, _b, _c;
-        if (!this.shouldRecordEvents()) {
-            return;
-        }
-        const events = (_a = this.snapshot.events) !== null && _a !== void 0 ? _a : (this.snapshot.events = []);
-        events.push({
-            type,
-            at: Date.now(),
-            detail
-        });
-        const max = (_c = (_b = this.getConfig()) === null || _b === void 0 ? void 0 : _b.maxEventRecords) !== null && _c !== void 0 ? _c : DEFAULT_MAX_EVENT_RECORDS;
-        if (events.length > max) {
-            events.splice(0, events.length - max);
+                exclude: definition.exclude,
+                suppress: definition.suppress
+            };
         }
+        return {
+            name,
+            priority: 0,
+            patch: value
+        };
     }
-    isEnabled() {
-        var _a;
-        return ((_a = this.getConfig()) === null || _a === void 0 ? void 0 : _a.enabled) === true;
-    }
-    shouldRecordEvents() {
-        const config = this.getConfig();
-        return !!(config === null || config === void 0 ? void 0 : config.enabled) && !!config.recordEvents;
-    }
-    getConfig() {
-        return typeof this.configSource === 'function' ? this.configSource() : this.configSource;
-    }
-}
-function ensureStageStatePerfMonitor(stage) {
-    const stageAny = stage;
-    if (!stageAny[STAGE_PERF_MONITOR]) {
-        stageAny[STAGE_PERF_MONITOR] = new StatePerfMonitor(() => stage.statePerfConfig);
-    }
-    return stageAny[STAGE_PERF_MONITOR];
-}
-function getStageStatePerfMonitor(stage) {
-    if (!stage) {
-        return undefined;
-    }
-    return stage[STAGE_PERF_MONITOR];
-}
-function getActiveStageStatePerfMonitor(stage) {
-    var _a;
-    if (!stage) {
-        return undefined;
-    }
-    const current = getStageStatePerfMonitor(stage);
-    if (current) {
-        return current;
+    expandRelationClosure(compiled, relation) {
+        const rawRelationMap = new Map();
+        compiled.forEach((definition, name) => {
+            rawRelationMap.set(name, new Set(definition[relation]));
+        });
+        compiled.forEach((definition, origin) => {
+            const closure = new Set();
+            const walk = (stateName, visiting) => {
+                const nextStates = rawRelationMap.get(stateName);
+                if (!nextStates || !nextStates.size) {
+                    return;
+                }
+                nextStates.forEach(nextState => {
+                    if (nextState === origin || visiting.has(nextState) || closure.has(nextState)) {
+                        return;
+                    }
+                    closure.add(nextState);
+                    visiting.add(nextState);
+                    walk(nextState, visiting);
+                    visiting.delete(nextState);
+                });
+            };
+            walk(origin, new Set([origin]));
+            definition[relation] = closure;
+        });
     }
-    return ((_a = stage.statePerfConfig) === null || _a === void 0 ? void 0 : _a.enabled) === true ? ensureStageStatePerfMonitor(stage) : undefined;
 }
 
-function isPlainObject$1(value) {
+function isPlainObject(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
-function cloneValue$1(value) {
-    if (!isPlainObject$1(value)) {
+function cloneValue(value) {
+    if (!isPlainObject(value)) {
         return value;
     }
     const clone = {};
     Object.keys(value).forEach(key => {
-        clone[key] = cloneValue$1(value[key]);
+        clone[key] = cloneValue(value[key]);
     });
     return clone;
 }
-function deepMerge$1(base, value) {
+function deepMerge(base, value) {
     var _a;
-    const result = (_a = cloneValue$1(base)) !== null && _a !== void 0 ? _a : {};
+    const result = (_a = cloneValue(base)) !== null && _a !== void 0 ? _a : {};
     Object.keys(value).forEach(key => {
         const nextValue = value[key];
         const previousValue = result[key];
-        if (isPlainObject$1(previousValue) && isPlainObject$1(nextValue)) {
-            result[key] = deepMerge$1(previousValue, nextValue);
+        if (isPlainObject(previousValue) && isPlainObject(nextValue)) {
+            result[key] = deepMerge(previousValue, nextValue);
             return;
         }
-        result[key] = cloneValue$1(nextValue);
+        result[key] = cloneValue(nextValue);
     });
     return result;
 }
-const FULL_DEFINITION_KEYS = new Set([
-    'name',
-    'patch',
-    'priority',
-    'exclude',
-    'suppress',
-    'resolver',
-    'declaredAffectedKeys'
-]);
 class StateEngine {
     constructor(options) {
         var _a;
@@ -9555,9 +8885,6 @@ class StateEngine {
         this.baseAttributes = {};
         this.compiledDefinitions = options.compiledDefinitions;
         this.stateSort = options.stateSort;
-        this.stateProxy = options.stateProxy;
-        this.stateProxyEligibility = options.stateProxyEligibility;
-        this.states = options.states;
         this.mergeMode = (_a = options.mergeMode) !== null && _a !== void 0 ? _a : 'shallow';
     }
     get activeStates() {
@@ -9656,11 +8983,9 @@ class StateEngine {
         };
     }
     invalidateResolverCache() {
-        var _a, _b;
         this.resolverPatchCache.clear();
         this.resolverCacheKey = '';
         this.resolverCacheValid = false;
-        (_b = getActiveStageStatePerfMonitor((_a = this.graphic) === null || _a === void 0 ? void 0 : _a.stage)) === null || _b === void 0 ? void 0 : _b.recordResolver('invalidations');
     }
     hasState(stateName) {
         if (!this._activeStates.length) {
@@ -9671,28 +8996,6 @@ class StateEngine {
         }
         return this._activeStates.includes(stateName);
     }
-    getCompatPatch(stateName) {
-        var _a, _b, _c;
-        const targetStates = this._activeStates.length ? this._activeStates : this._effectiveStates;
-        const canUseStateProxy = this.canUseStateProxy(stateName);
-        const proxyPatch = canUseStateProxy ? (_a = this.stateProxy) === null || _a === void 0 ? void 0 : _a.call(this, stateName, targetStates) : undefined;
-        if (this.stateProxy && canUseStateProxy) {
-            return proxyPatch !== null && proxyPatch !== void 0 ? proxyPatch : undefined;
-        }
-        const value = (_b = this.states) === null || _b === void 0 ? void 0 : _b[stateName];
-        if (value == null) {
-            return undefined;
-        }
-        if (!isPlainObject$1(value)) {
-            return value;
-        }
-        const keys = Object.keys(value);
-        const hasFullKey = keys.some(key => FULL_DEFINITION_KEYS.has(key));
-        if (!hasFullKey) {
-            return value;
-        }
-        return cloneValue$1(((_c = value.patch) !== null && _c !== void 0 ? _c : undefined));
-    }
     sortStates(states) {
         const withDefinition = [];
         const withoutDefinition = [];
@@ -9713,364 +9016,105 @@ class StateEngine {
             if (leftDefinition.priority !== rightDefinition.priority) {
                 return leftDefinition.priority - rightDefinition.priority;
             }
-            return leftDefinition.rank - rightDefinition.rank;
-        });
-        if (this.stateSort && withoutDefinition.length > 1) {
-            withoutDefinition.sort(this.stateSort);
-        }
-        return withDefinition.concat(withoutDefinition);
-    }
-    adjudicate(sortedStates) {
-        const candidate = sortedStates.slice();
-        const suppressedSet = new Set();
-        for (let index = candidate.length - 1; index >= 0; index--) {
-            const stateName = candidate[index];
-            const definition = this.compiledDefinitions.get(stateName);
-            if (!definition) {
-                continue;
-            }
-            definition.exclude.forEach(excludedState => {
-                const excludedIndex = candidate.indexOf(excludedState);
-                if (excludedIndex === -1) {
-                    return;
-                }
-                candidate.splice(excludedIndex, 1);
-                if (excludedIndex < index) {
-                    index -= 1;
-                }
-            });
-            definition.suppress.forEach(suppressedState => {
-                suppressedSet.add(suppressedState);
-            });
-        }
-        return {
-            active: candidate,
-            suppressedSet
-        };
-    }
-    recomputePatch(effectiveStates) {
-        var _a;
-        const perfMonitor = getActiveStageStatePerfMonitor((_a = this.graphic) === null || _a === void 0 ? void 0 : _a.stage);
-        const patchStart = perfMonitor ? performance.now() : 0;
-        let resolverCost = 0;
-        const cacheKey = effectiveStates.join(',');
-        const nextPatch = {};
-        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordAllocation('patchObjectsCreated');
-        if (this.resolverCacheValid && this.resolverCacheKey === cacheKey) {
-            effectiveStates.forEach(stateName => {
-                var _a;
-                const canUseStateProxy = this.canUseStateProxy(stateName);
-                const proxyPatch = canUseStateProxy ? (_a = this.stateProxy) === null || _a === void 0 ? void 0 : _a.call(this, stateName, effectiveStates) : undefined;
-                if (this.stateProxy && canUseStateProxy) {
-                    if (proxyPatch != null) {
-                        this.mergeInto(nextPatch, proxyPatch);
-                    }
-                    return;
-                }
-                const definition = this.compiledDefinitions.get(stateName);
-                if (!definition) {
-                    const compatPatch = this.getCompatPatch(stateName);
-                    if (compatPatch) {
-                        this.mergeInto(nextPatch, compatPatch);
-                    }
-                    return;
-                }
-                if (definition.patch) {
-                    this.mergeInto(nextPatch, definition.patch);
-                }
-                if (definition.hasResolver) {
-                    const cachedPatch = this.resolverPatchCache.get(stateName);
-                    if (cachedPatch) {
-                        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordResolver('cacheHits');
-                        this.mergeInto(nextPatch, cachedPatch);
-                    }
-                }
-            });
-        }
-        else {
-            this.resolverPatchCache.clear();
-            this.resolverCacheKey = cacheKey;
-            effectiveStates.forEach(stateName => {
-                var _a;
-                const canUseStateProxy = this.canUseStateProxy(stateName);
-                const proxyPatch = canUseStateProxy ? (_a = this.stateProxy) === null || _a === void 0 ? void 0 : _a.call(this, stateName, effectiveStates) : undefined;
-                if (this.stateProxy && canUseStateProxy) {
-                    if (proxyPatch != null) {
-                        this.mergeInto(nextPatch, proxyPatch);
-                    }
-                    return;
-                }
-                const definition = this.compiledDefinitions.get(stateName);
-                if (!definition) {
-                    const compatPatch = this.getCompatPatch(stateName);
-                    if (compatPatch) {
-                        this.mergeInto(nextPatch, compatPatch);
-                    }
-                    return;
-                }
-                if (definition.patch) {
-                    this.mergeInto(nextPatch, definition.patch);
-                }
-                if (definition.hasResolver && definition.resolver) {
-                    perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordResolver('cacheMisses');
-                    const resolverStart = perfMonitor ? performance.now() : 0;
-                    const resolverPatch = definition.resolver({
-                        graphic: this.graphic,
-                        activeStates: this._activeStates,
-                        effectiveStates: this._effectiveStates,
-                        baseAttributes: this.baseAttributes,
-                        resolvedPatch: nextPatch
-                    });
-                    if (perfMonitor) {
-                        const duration = performance.now() - resolverStart;
-                        resolverCost += duration;
-                        perfMonitor.recordCost('resolver', duration);
-                    }
-                    if (resolverPatch) {
-                        this.resolverPatchCache.set(stateName, resolverPatch);
-                        this.mergeInto(nextPatch, resolverPatch);
-                    }
-                }
-            });
-            this.resolverCacheValid = true;
-        }
-        this._resolvedPatch = nextPatch;
-        if (perfMonitor) {
-            const totalCost = performance.now() - patchStart;
-            perfMonitor.recordCost('patch', Math.max(0, totalCost - resolverCost));
-        }
-    }
-    mergeInto(target, patch) {
-        if (this.mergeMode === 'deep') {
-            Object.keys(patch).forEach(key => {
-                var _a;
-                const nextValue = patch[key];
-                const previousValue = target[key];
-                const baseValue = (_a = this.baseAttributes) === null || _a === void 0 ? void 0 : _a[key];
-                if (isPlainObject$1(previousValue) && isPlainObject$1(nextValue)) {
-                    target[key] = deepMerge$1(previousValue, nextValue);
-                    return;
-                }
-                if (!isPlainObject$1(previousValue) && isPlainObject$1(baseValue) && isPlainObject$1(nextValue)) {
-                    target[key] = deepMerge$1(baseValue, nextValue);
-                    return;
-                }
-                target[key] = cloneValue$1(nextValue);
-            });
-            return;
-        }
-        Object.keys(patch).forEach(key => {
-            target[key] = cloneValue$1(patch[key]);
-        });
-    }
-    sameArray(left, right) {
-        if (left.length !== right.length) {
-            return false;
-        }
-        for (let index = 0; index < left.length; index++) {
-            if (left[index] !== right[index]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    canUseStateProxy(stateName) {
-        if (!this.stateProxy) {
-            return false;
-        }
-        return this.stateProxyEligibility ? this.stateProxyEligibility(stateName) : true;
-    }
-}
-
-class StateModel {
-    constructor(options = {}) {
-        var _a;
-        this.exclusiveGroupMap = new Map();
-        this.exclusiveGroups = new Map();
-        this.states = options.states;
-        this.currentStates = options.currentStates ? [...options.currentStates] : undefined;
-        this.stateSort = options.stateSort;
-        this.stateProxy = options.stateProxy;
-        this.stateEngine = options.stateEngine;
-        if (this.stateEngine &&
-            options.currentStates &&
-            !this.sameStates(this.stateEngine.activeStates, options.currentStates)) {
-            this.stateEngine.applyStates(options.currentStates);
-        }
-        const exclusiveGroups = (_a = options.exclusiveGroups) !== null && _a !== void 0 ? _a : {};
-        for (const groupName in exclusiveGroups) {
-            if (!Object.prototype.hasOwnProperty.call(exclusiveGroups, groupName)) {
-                continue;
-            }
-            this.registerExclusiveGroup(groupName, exclusiveGroups[groupName]);
-        }
-    }
-    getCurrentStates() {
-        return this.currentStates ? [...this.currentStates] : [];
-    }
-    hasState(stateName) {
-        if (this.stateEngine) {
-            return this.stateEngine.hasState(stateName);
-        }
-        if (!this.currentStates || !this.currentStates.length) {
-            return false;
-        }
-        if (stateName == null) {
-            return true;
-        }
-        return this.currentStates.includes(stateName);
-    }
-    getState(stateName) {
-        var _a;
-        return (_a = this.states) === null || _a === void 0 ? void 0 : _a[stateName];
-    }
-    useStates(states) {
-        var _a;
-        if (this.stateEngine) {
-            const result = this.stateEngine.applyStates(states);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (!states.length) {
-            return this.clearStates();
-        }
-        const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : [];
-        const changed = previousStates.length !== states.length || states.some((stateName, index) => previousStates[index] !== stateName);
-        const nextStates = this.sortStates(states);
-        if (changed) {
-            this.currentStates = nextStates;
-        }
-        return {
-            changed,
-            states: changed ? [...nextStates] : [...previousStates]
-        };
-    }
-    clearStates() {
-        if (this.stateEngine) {
-            const result = this.stateEngine.clearStates();
-            this.currentStates = [];
-            return {
-                changed: result.changed,
-                states: [],
-                effectiveStates: []
-            };
-        }
-        const changed = this.hasState();
-        this.currentStates = [];
-        return {
-            changed,
-            states: []
-        };
-    }
-    addState(stateName, keepCurrentStates) {
-        var _a;
-        if (this.stateEngine) {
-            const result = this.stateEngine.addState(stateName, keepCurrentStates);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (this.currentStates &&
-            this.currentStates.includes(stateName) &&
-            (keepCurrentStates || this.currentStates.length === 1)) {
-            return {
-                changed: false,
-                states: this.getCurrentStates()
-            };
-        }
-        const nextStates = keepCurrentStates && ((_a = this.currentStates) === null || _a === void 0 ? void 0 : _a.length) ? this.currentStates.concat([stateName]) : [stateName];
-        return this.useStates(nextStates);
-    }
-    removeState(stateName) {
-        if (this.stateEngine) {
-            const result = this.stateEngine.removeState(stateName);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (!this.currentStates) {
-            return {
-                changed: false,
-                states: []
-            };
-        }
-        const filter = Array.isArray(stateName) ? (s) => !stateName.includes(s) : (s) => s !== stateName;
-        const nextStates = this.currentStates.filter(filter);
-        if (nextStates.length === this.currentStates.length) {
-            return {
-                changed: false,
-                states: this.getCurrentStates()
-            };
+            return leftDefinition.rank - rightDefinition.rank;
+        });
+        if (this.stateSort && withoutDefinition.length > 1) {
+            withoutDefinition.sort(this.stateSort);
         }
-        return this.useStates(nextStates);
+        return withDefinition.concat(withoutDefinition);
     }
-    toggleState(stateName) {
-        if (this.stateEngine) {
-            const result = this.stateEngine.toggleState(stateName);
-            this.currentStates = [...result.activeStates];
-            return {
-                changed: result.changed,
-                states: [...result.activeStates],
-                effectiveStates: [...result.effectiveStates]
-            };
-        }
-        if (this.hasState(stateName)) {
-            return this.removeState(stateName);
-        }
-        const nextStates = this.currentStates ? this.currentStates.slice() : [];
-        if (!nextStates.includes(stateName)) {
-            nextStates.push(stateName);
+    adjudicate(sortedStates) {
+        const candidate = sortedStates.slice();
+        const suppressedSet = new Set();
+        for (let index = candidate.length - 1; index >= 0; index--) {
+            const stateName = candidate[index];
+            const definition = this.compiledDefinitions.get(stateName);
+            if (!definition) {
+                continue;
+            }
+            definition.exclude.forEach(excludedState => {
+                const excludedIndex = candidate.indexOf(excludedState);
+                if (excludedIndex === -1) {
+                    return;
+                }
+                candidate.splice(excludedIndex, 1);
+                if (excludedIndex < index) {
+                    index -= 1;
+                }
+            });
+            definition.suppress.forEach(suppressedState => {
+                suppressedSet.add(suppressedState);
+            });
         }
-        return this.useStates(nextStates);
+        return {
+            active: candidate,
+            suppressedSet
+        };
     }
-    sortStates(states) {
-        if (this.stateEngine) {
-            return [...this.stateEngine.activeStates];
+    recomputePatch(effectiveStates) {
+        const cacheKey = effectiveStates.join(',');
+        const nextPatch = {};
+        const useResolverCache = this.resolverCacheValid && this.resolverCacheKey === cacheKey;
+        if (!useResolverCache) {
+            this.resolverPatchCache.clear();
+            this.resolverCacheKey = cacheKey;
         }
-        if (!this.stateSort) {
-            return [...states];
+        effectiveStates.forEach(stateName => {
+            var _a;
+            const definition = this.compiledDefinitions.get(stateName);
+            if (!definition) {
+                return;
+            }
+            if (definition.patch) {
+                this.mergeInto(nextPatch, definition.patch);
+            }
+            if (definition.hasResolver) {
+                const resolverPatch = useResolverCache
+                    ? this.resolverPatchCache.get(stateName)
+                    : (_a = definition.resolver) === null || _a === void 0 ? void 0 : _a.call(definition, {
+                        graphic: this.graphic,
+                        activeStates: this._activeStates,
+                        effectiveStates: this._effectiveStates,
+                        baseAttributes: this.baseAttributes,
+                        resolvedPatch: nextPatch
+                    });
+                if (resolverPatch) {
+                    if (!useResolverCache) {
+                        this.resolverPatchCache.set(stateName, resolverPatch);
+                    }
+                    this.mergeInto(nextPatch, resolverPatch);
+                }
+            }
+        });
+        if (!useResolverCache) {
+            this.resolverCacheValid = true;
         }
-        return [...states].sort(this.stateSort);
-    }
-    registerExclusiveGroup(groupName, states) {
-        const uniqueStates = Array.from(new Set(states));
-        this.exclusiveGroups.set(groupName, uniqueStates);
-        uniqueStates.forEach(stateName => this.exclusiveGroupMap.set(stateName, groupName));
-    }
-    getExclusiveGroup(stateName) {
-        return this.exclusiveGroupMap.get(stateName);
+        this._resolvedPatch = nextPatch;
     }
-    getMutuallyExclusiveStates(stateName) {
-        var _a;
-        const groupName = this.getExclusiveGroup(stateName);
-        if (!groupName) {
-            return [];
+    mergeInto(target, patch) {
+        if (this.mergeMode === 'deep') {
+            Object.keys(patch).forEach(key => {
+                var _a;
+                const nextValue = patch[key];
+                const previousValue = target[key];
+                const baseValue = (_a = this.baseAttributes) === null || _a === void 0 ? void 0 : _a[key];
+                if (isPlainObject(previousValue) && isPlainObject(nextValue)) {
+                    target[key] = deepMerge(previousValue, nextValue);
+                    return;
+                }
+                if (!isPlainObject(previousValue) && isPlainObject(baseValue) && isPlainObject(nextValue)) {
+                    target[key] = deepMerge(baseValue, nextValue);
+                    return;
+                }
+                target[key] = cloneValue(nextValue);
+            });
+            return;
         }
-        return ((_a = this.exclusiveGroups.get(groupName)) !== null && _a !== void 0 ? _a : []).filter(name => name !== stateName);
-    }
-    isMutuallyExclusive(stateA, stateB) {
-        const groupName = this.getExclusiveGroup(stateA);
-        return !!groupName && groupName === this.getExclusiveGroup(stateB) && stateA !== stateB;
-    }
-    get effectiveStates() {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.effectiveStates) !== null && _b !== void 0 ? _b : this.currentStates) !== null && _c !== void 0 ? _c : [];
-    }
-    get resolvedPatch() {
-        var _a;
-        return (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.resolvedPatch;
+        Object.keys(patch).forEach(key => {
+            target[key] = cloneValue(patch[key]);
+        });
     }
-    sameStates(left, right) {
+    sameArray(left, right) {
         if (left.length !== right.length) {
             return false;
         }
@@ -10083,76 +9127,67 @@ class StateModel {
     }
 }
 
-function isPlainObject(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-function cloneValue(value) {
-    if (!isPlainObject(value)) {
-        return value;
-    }
-    const clone = {};
-    for (const key in value) {
-        if (!Object.prototype.hasOwnProperty.call(value, key)) {
-            continue;
-        }
-        clone[key] = cloneValue(value[key]);
-    }
-    return clone;
-}
-function deepMerge(base, value) {
-    const result = cloneValue(base) || {};
-    for (const key in value) {
-        if (!Object.prototype.hasOwnProperty.call(value, key)) {
-            continue;
-        }
-        const nextValue = value[key];
-        const previousValue = result[key];
-        if (isPlainObject(previousValue) && isPlainObject(nextValue)) {
-            result[key] = deepMerge(previousValue, nextValue);
+var UpdateCategory;
+(function (UpdateCategory) {
+    UpdateCategory[UpdateCategory["NONE"] = 0] = "NONE";
+    UpdateCategory[UpdateCategory["PAINT"] = 1] = "PAINT";
+    UpdateCategory[UpdateCategory["SHAPE"] = 2] = "SHAPE";
+    UpdateCategory[UpdateCategory["BOUNDS"] = 4] = "BOUNDS";
+    UpdateCategory[UpdateCategory["TRANSFORM"] = 8] = "TRANSFORM";
+    UpdateCategory[UpdateCategory["LAYOUT"] = 16] = "LAYOUT";
+    UpdateCategory[UpdateCategory["PICK"] = 32] = "PICK";
+})(UpdateCategory || (UpdateCategory = {}));
+const ATTRIBUTE_CATEGORY = {
+    fill: UpdateCategory.PAINT,
+    opacity: UpdateCategory.PAINT,
+    fillOpacity: UpdateCategory.PAINT,
+    strokeOpacity: UpdateCategory.PAINT,
+    lineDash: UpdateCategory.PAINT,
+    lineDashOffset: UpdateCategory.PAINT,
+    lineCap: UpdateCategory.PAINT,
+    lineJoin: UpdateCategory.PAINT,
+    miterLimit: UpdateCategory.PAINT,
+    shadowColor: UpdateCategory.PAINT,
+    x: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    y: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    scaleX: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    scaleY: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    angle: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    anchor: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    anchor3d: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    postMatrix: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    layout: UpdateCategory.LAYOUT,
+    zIndex: UpdateCategory.PAINT,
+    visible: UpdateCategory.PAINT | UpdateCategory.PICK,
+    lineWidth: UpdateCategory.SHAPE | UpdateCategory.BOUNDS | UpdateCategory.PICK,
+    width: UpdateCategory.SHAPE | UpdateCategory.BOUNDS,
+    height: UpdateCategory.SHAPE | UpdateCategory.BOUNDS
+};
+const ATTRIBUTE_DELTA_CLASSIFIER = {
+    stroke: (prev, next) => {
+        const prevEnabled = prev != null && prev !== false;
+        const nextEnabled = next != null && next !== false;
+        if (prevEnabled !== nextEnabled) {
+            return UpdateCategory.PAINT | UpdateCategory.BOUNDS | UpdateCategory.PICK;
         }
-        else {
-            result[key] = cloneValue(nextValue);
+        return UpdateCategory.PAINT;
+    },
+    shadowBlur: (prev, next) => {
+        const prevBlur = Number(prev !== null && prev !== void 0 ? prev : 0);
+        const nextBlur = Number(next !== null && next !== void 0 ? next : 0);
+        if (prevBlur !== nextBlur && (prevBlur > 0 || nextBlur > 0)) {
+            return UpdateCategory.PAINT | UpdateCategory.BOUNDS;
         }
+        return UpdateCategory.PAINT;
     }
-    return result;
-}
-class StateStyleResolver {
-    constructor(options = {}) {
-        this.options = options;
-    }
-    resolve(normalAttrs, states, stateProxy, currentStates, stateSort) {
-        var _a;
-        const mergeMode = (_a = this.options.mergeMode) !== null && _a !== void 0 ? _a : 'shallow';
-        const sortedStates = stateSort ? currentStates.slice().sort(stateSort) : currentStates.slice();
-        const resolvedAttrs = {};
-        sortedStates.forEach(stateName => {
-            const attrs = stateProxy ? stateProxy(stateName, sortedStates) : states === null || states === void 0 ? void 0 : states[stateName];
-            if (attrs == null) {
-                return;
-            }
-            for (const key in attrs) {
-                if (!Object.prototype.hasOwnProperty.call(attrs, key)) {
-                    continue;
-                }
-                const nextValue = attrs[key];
-                if (mergeMode === 'deep' &&
-                    isPlainObject(nextValue) &&
-                    (isPlainObject(resolvedAttrs[key]) ||
-                        isPlainObject(normalAttrs[key]))) {
-                    const baseValue = isPlainObject(resolvedAttrs[key])
-                        ? resolvedAttrs[key]
-                        : isPlainObject(normalAttrs[key])
-                            ? normalAttrs[key]
-                            : {};
-                    resolvedAttrs[key] = deepMerge(baseValue, nextValue);
-                }
-                else {
-                    resolvedAttrs[key] = cloneValue(nextValue);
-                }
-            }
-        });
-        return resolvedAttrs;
+};
+function classifyAttributeDelta(key, prev, next) {
+    var _a;
+    const dynamicClassifier = ATTRIBUTE_DELTA_CLASSIFIER[key];
+    if (dynamicClassifier) {
+        return dynamicClassifier(prev, next);
     }
+    return (_a = ATTRIBUTE_CATEGORY[key]) !== null && _a !== void 0 ? _a : UpdateCategory.PAINT;
 }
 
 function hasOwnKeys(value) {
@@ -10176,13 +9211,11 @@ function normalizeNoAnimateAttrConfig(config) {
     }, {});
 }
 class StateTransitionOrchestrator {
-    analyzeTransition(_currentAttrs, targetAttrs, stateNames, hasAnimation, options = {}) {
+    analyzeTransition(targetAttrs, hasAnimation, options = {}) {
         var _a, _b;
         const plan = {
-            stateNames,
             targetAttrs: Object.assign({}, targetAttrs),
             animateAttrs: {},
-            jumpAttrs: {},
             noAnimateAttrs: {}
         };
         if (!hasAnimation) {
@@ -10191,10 +9224,10 @@ class StateTransitionOrchestrator {
         const noWorkAnimateAttr = Object.assign(Object.assign({}, ((_a = options.noWorkAnimateAttr) !== null && _a !== void 0 ? _a : {})), normalizeNoAnimateAttrConfig((_b = options.animateConfig) === null || _b === void 0 ? void 0 : _b.noAnimateAttrs));
         const isClear = options.isClear === true;
         const getDefaultAttribute = options.getDefaultAttribute;
+        const readDefaultAttribute = getDefaultAttribute;
         const shouldSkipDefaultAttribute = options.shouldSkipDefaultAttribute;
         const assignTransitionAttr = (key, value) => {
             if (noWorkAnimateAttr[key]) {
-                plan.jumpAttrs[key] = value;
                 plan.noAnimateAttrs[key] = value;
                 return;
             }
@@ -10202,7 +9235,7 @@ class StateTransitionOrchestrator {
                 if (shouldSkipDefaultAttribute === null || shouldSkipDefaultAttribute === void 0 ? void 0 : shouldSkipDefaultAttribute(key, targetAttrs)) {
                     return;
                 }
-                plan.animateAttrs[key] = getDefaultAttribute ? getDefaultAttribute(key) : value;
+                plan.animateAttrs[key] = readDefaultAttribute(key);
                 return;
             }
             plan.animateAttrs[key] = value;
@@ -10256,13 +9289,13 @@ class StateTransitionOrchestrator {
         graphic._emitCustomEvent('afterStateUpdate', { type: AttributeUpdateType.STATE });
         return plan;
     }
-    applyClearTransition(graphic, targetAttrs, hasAnimation, stateNames, options = {}) {
-        var _a, _b, _c, _d;
-        const plan = this.analyzeTransition({}, targetAttrs, stateNames, hasAnimation, {
-            noWorkAnimateAttr: (_a = graphic.getNoWorkAnimateAttr) === null || _a === void 0 ? void 0 : _a.call(graphic),
+    applyClearTransition(graphic, targetAttrs, hasAnimation, options = {}) {
+        var _a;
+        const plan = this.analyzeTransition(targetAttrs, hasAnimation, {
+            noWorkAnimateAttr: graphic.getNoWorkAnimateAttr(),
             isClear: true,
-            getDefaultAttribute: (_b = graphic.getDefaultAttribute) === null || _b === void 0 ? void 0 : _b.bind(graphic),
-            shouldSkipDefaultAttribute: (_c = options.shouldSkipDefaultAttribute) !== null && _c !== void 0 ? _c : (_d = graphic.shouldSkipStateTransitionDefaultAttribute) === null || _d === void 0 ? void 0 : _d.bind(graphic),
+            getDefaultAttribute: graphic.getDefaultAttribute.bind(graphic),
+            shouldSkipDefaultAttribute: (_a = options.shouldSkipDefaultAttribute) !== null && _a !== void 0 ? _a : graphic.shouldSkipStateTransitionDefaultAttribute.bind(graphic),
             animateConfig: options.animateConfig,
             extraAnimateAttrs: options.extraAnimateAttrs
         });
@@ -10271,33 +9304,11 @@ class StateTransitionOrchestrator {
 }
 
 const compiler = new StateDefinitionCompiler();
-function copyDefinitions(definitions) {
-    return definitions ? Object.assign({}, definitions) : {};
-}
 function buildEffectiveSourceDefinitions(parentScope, localStateDefinitions, themeStateDefinitions) {
-    const merged = parentScope
-        ? copyDefinitions(parentScope.effectiveSourceDefinitions)
-        : copyDefinitions(themeStateDefinitions);
-    if (localStateDefinitions) {
-        Object.keys(localStateDefinitions).forEach(stateName => {
-            merged[stateName] = localStateDefinitions[stateName];
-        });
-    }
-    return merged;
-}
-function initializeScope(scope, revision = 0) {
-    var _a;
-    const effectiveSourceDefinitions = buildEffectiveSourceDefinitions(scope.parentScope, scope.localStateDefinitions, scope.themeStateDefinitions);
-    scope.effectiveSourceDefinitions = effectiveSourceDefinitions;
-    scope.effectiveCompiledDefinitions = compiler.compile(effectiveSourceDefinitions);
-    scope.parentRevisionAtBuild = (_a = scope.parentScope) === null || _a === void 0 ? void 0 : _a.revision;
-    scope.revision = revision;
-    scope.dirty = false;
-    return scope;
+    return Object.assign({}, parentScope ? parentScope.effectiveSourceDefinitions : themeStateDefinitions, localStateDefinitions);
 }
 function createRootSharedStateScope(stage, themeStateDefinitions) {
-    return initializeScope({
-        ownerKind: 'root',
+    return rebuildSharedStateScope({
         ownerStage: stage,
         themeStateDefinitions,
         effectiveSourceDefinitions: {},
@@ -10308,9 +9319,7 @@ function createRootSharedStateScope(stage, themeStateDefinitions) {
     }, 0);
 }
 function createGroupSharedStateScope(group, parentScope, localStateDefinitions) {
-    return initializeScope({
-        ownerKind: 'group',
-        ownerGroup: group,
+    return rebuildSharedStateScope({
         ownerStage: group.stage,
         parentScope,
         localStateDefinitions,
@@ -10345,22 +9354,20 @@ function setRootSharedStateScopeThemeDefinitions(scope, themeStateDefinitions) {
     rebuildSharedStateScope(scope);
     return true;
 }
-function rebuildSharedStateScope(scope) {
+function rebuildSharedStateScope(scope, revision = scope.revision + 1) {
     var _a;
     const effectiveSourceDefinitions = buildEffectiveSourceDefinitions(scope.parentScope, scope.localStateDefinitions, scope.themeStateDefinitions);
     scope.effectiveSourceDefinitions = effectiveSourceDefinitions;
     scope.effectiveCompiledDefinitions = compiler.compile(effectiveSourceDefinitions);
     scope.parentRevisionAtBuild = (_a = scope.parentScope) === null || _a === void 0 ? void 0 : _a.revision;
-    scope.revision += 1;
+    scope.revision = revision;
     scope.dirty = false;
     return scope;
 }
 function ensureSharedStateScopeFresh(scope) {
-    var _a;
     if (!scope) {
         return undefined;
     }
-    (_a = getActiveStageStatePerfMonitor(scope.ownerStage)) === null || _a === void 0 ? void 0 : _a.recordRefresh('ensureFreshCalls');
     if (scope.parentScope) {
         ensureSharedStateScopeFresh(scope.parentScope);
     }
@@ -10380,11 +9387,9 @@ function collectSharedStateScopeChain(scope) {
 }
 
 function scheduleStageSharedStateRefresh(stage) {
-    var _a;
     if (!stage || stage.releaseStatus === 'released') {
         return;
     }
-    (_a = getActiveStageStatePerfMonitor(stage)) === null || _a === void 0 ? void 0 : _a.recordRefresh('renderScheduled');
     stage.renderNextFrame();
 }
 function enqueueGraphicSharedStateRefresh(stage, graphic) {
@@ -10393,36 +9398,27 @@ function enqueueGraphicSharedStateRefresh(stage, graphic) {
         return;
     }
     const pending = (_a = stage._pendingSharedStateRefreshGraphics) !== null && _a !== void 0 ? _a : (stage._pendingSharedStateRefreshGraphics = new Set());
-    if (!pending.has(graphic)) {
-        pending.add(graphic);
-        const perfMonitor = getActiveStageStatePerfMonitor(stage);
-        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordRefresh('queuedGraphics');
-        perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordAllocation('refreshQueuePushes');
-    }
+    pending.add(graphic);
 }
 function markScopeActiveDescendantsDirty(scope, stage) {
-    let marked = false;
+    if (!scope.subtreeActiveDescendants.size) {
+        return;
+    }
     scope.subtreeActiveDescendants.forEach(graphic => {
         var _a;
         graphic.sharedStateDirty = true;
         const ownerStage = (_a = stage !== null && stage !== void 0 ? stage : graphic.stage) !== null && _a !== void 0 ? _a : scope.ownerStage;
         enqueueGraphicSharedStateRefresh(ownerStage, graphic);
-        marked = true;
     });
-    if (marked) {
-        scheduleStageSharedStateRefresh(stage !== null && stage !== void 0 ? stage : scope.ownerStage);
-    }
+    scheduleStageSharedStateRefresh(stage !== null && stage !== void 0 ? stage : scope.ownerStage);
 }
 function flushStageSharedStateRefresh(stage) {
     const pending = stage._pendingSharedStateRefreshGraphics;
     if (!pending || !pending.size) {
         return;
     }
-    const perfMonitor = getActiveStageStatePerfMonitor(stage);
-    const start = perfMonitor ? performance.now() : 0;
     const graphics = Array.from(pending.values());
     pending.clear();
-    perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordRefresh('flushedGraphics', graphics.length);
     graphics.forEach(graphic => {
         if (graphic.releaseStatus === 'released') {
             return;
@@ -10433,23 +9429,13 @@ function flushStageSharedStateRefresh(stage) {
         if (!graphic.sharedStateDirty) {
             return;
         }
-        const refresh = graphic.refreshSharedStateBeforeRender;
-        if (typeof refresh === 'function') {
-            refresh.call(graphic);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('sharedRefreshCommits');
-        }
+        graphic.refreshSharedStateBeforeRender();
     });
-    if (perfMonitor) {
-        perfMonitor.recordCost('sharedRefresh', performance.now() - start);
-        perfMonitor.recordEvent('shared-refresh-flush', {
-            stageId: stage._uid,
-            flushedGraphics: graphics.length
-        });
-    }
 }
 
 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',
@@ -10485,18 +9471,8 @@ const builtinTextureTypes = new Set([
     'grid',
     'wave'
 ]);
-const FULL_STATE_DEFINITION_KEYS = new Set([
-    'name',
-    'patch',
-    'priority',
-    'exclude',
-    'suppress',
-    'resolver',
-    'declaredAffectedKeys'
-]);
 const point = new Point();
 const EMPTY_STATE_NAMES = [];
-const deprecatedLocalStateFallbackWarningStateNames = new Set();
 const BROAD_UPDATE_CATEGORY = UpdateCategory.PAINT |
     UpdateCategory.SHAPE |
     UpdateCategory.BOUNDS |
@@ -10650,18 +9626,6 @@ class Graphic extends Node {
     getAttributes() {
         return this.attribute;
     }
-    getStateStyleResolver(mergeMode) {
-        if (mergeMode === 'deep') {
-            if (!this.deepStateStyleResolver) {
-                this.deepStateStyleResolver = new StateStyleResolver({ mergeMode: 'deep' });
-            }
-            return this.deepStateStyleResolver;
-        }
-        if (!this.stateStyleResolver) {
-            this.stateStyleResolver = new StateStyleResolver();
-        }
-        return this.stateStyleResolver;
-    }
     getStateTransitionOrchestrator() {
         if (!this.stateTransitionOrchestrator) {
             this.stateTransitionOrchestrator = new StateTransitionOrchestrator();
@@ -10688,12 +9652,10 @@ class Graphic extends Node {
         }
         this.boundSharedStateScope = nextScope;
         this.boundSharedStateRevision = undefined;
-        this.localFallbackCompiledDefinitions = undefined;
         this.compiledStateDefinitions = undefined;
         this.compiledStateDefinitionsCacheKey = undefined;
         this.stateEngine = undefined;
         this.stateEngineCompiledDefinitions = undefined;
-        this.stateEngineStateProxyModeKey = undefined;
         this.syncSharedStateActiveRegistrations();
         if (markDirty && ((_a = this.currentStates) === null || _a === void 0 ? void 0 : _a.length)) {
             this.markSharedStateDirty();
@@ -10776,20 +9738,9 @@ class Graphic extends Node {
         var _a, _b;
         if (this.localStateDefinitionsSource !== this.states) {
             this.localStateDefinitionsSource = this.states;
-            this.localFallbackVersion = ((_a = this.localFallbackVersion) !== null && _a !== void 0 ? _a : 0) + 1;
-        }
-        return (_b = this.localFallbackVersion) !== null && _b !== void 0 ? _b : 0;
-    }
-    warnDeprecatedLocalStatesFallback(stateNames) {
-        for (let index = 0; index < stateNames.length; index++) {
-            const stateName = stateNames[index];
-            if (deprecatedLocalStateFallbackWarningStateNames.has(stateName)) {
-                continue;
-            }
-            deprecatedLocalStateFallbackWarningStateNames.add(stateName);
-            console.warn(`[VRender] graphic.states fallback for missing shared state definition "${stateName}" is deprecated. ` +
-                'Move the state definition to sharedStateDefinitions or use stateProxy for dynamic per-graphic styles.');
+            this.localStateDefinitionsVersion = ((_a = this.localStateDefinitionsVersion) !== null && _a !== void 0 ? _a : 0) + 1;
         }
+        return (_b = this.localStateDefinitionsVersion) !== null && _b !== void 0 ? _b : 0;
     }
     resolveEffectiveCompiledDefinitions() {
         this.syncSharedStateScopeBindingFromTree(false);
@@ -10802,8 +9753,7 @@ class Graphic extends Node {
         if (!boundScope) {
             if (!hasStates) {
                 return {
-                    compiledDefinitions: undefined,
-                    stateProxyModeKey: 'none'
+                    compiledDefinitions: undefined
                 };
             }
             const localStatesVersion = this.getLocalStatesVersion();
@@ -10813,53 +9763,12 @@ class Graphic extends Node {
                 this.compiledStateDefinitionsCacheKey = cacheKey;
             }
             return {
-                compiledDefinitions: this.compiledStateDefinitions,
-                stateProxyModeKey: this.stateProxy ? 'legacy-all' : 'none'
+                compiledDefinitions: this.compiledStateDefinitions
             };
         }
         const sharedCompiledDefinitions = boundScope.effectiveCompiledDefinitions;
-        const sharedStateProxyModeKey = this.stateProxy ? 'shared-missing-only' : 'none';
-        const sharedStateProxyEligibility = this.stateProxy
-            ? (stateName) => !sharedCompiledDefinitions.has(stateName)
-            : undefined;
-        if (!hasStates) {
-            this.localFallbackCompiledDefinitions = undefined;
-            return {
-                compiledDefinitions: sharedCompiledDefinitions,
-                stateProxyModeKey: sharedStateProxyModeKey,
-                stateProxyEligibility: sharedStateProxyEligibility
-            };
-        }
-        const localStates = this.states;
-        const missingLocalStateDefinitions = {};
-        const missingStateNames = [];
-        Object.keys(localStates).forEach(stateName => {
-            if (sharedCompiledDefinitions.has(stateName)) {
-                return;
-            }
-            missingLocalStateDefinitions[stateName] = localStates[stateName];
-            missingStateNames.push(stateName);
-        });
-        if (!missingStateNames.length) {
-            this.localFallbackCompiledDefinitions = undefined;
-            return {
-                compiledDefinitions: sharedCompiledDefinitions,
-                stateProxyModeKey: sharedStateProxyModeKey,
-                stateProxyEligibility: sharedStateProxyEligibility
-            };
-        }
-        this.warnDeprecatedLocalStatesFallback(missingStateNames);
-        const localStatesVersion = this.getLocalStatesVersion();
-        const stateProxyModeKey = this.stateProxy ? `missing:${missingStateNames.sort().join('|')}` : 'none';
-        const cacheKey = `shared:${boundScope.revision}:fallback:${localStatesVersion}:${stateProxyModeKey}`;
-        if (!this.localFallbackCompiledDefinitions || this.compiledStateDefinitionsCacheKey !== cacheKey) {
-            this.localFallbackCompiledDefinitions = new StateDefinitionCompiler().compile(Object.assign(Object.assign({}, boundScope.effectiveSourceDefinitions), missingLocalStateDefinitions));
-            this.compiledStateDefinitionsCacheKey = cacheKey;
-        }
         return {
-            compiledDefinitions: this.localFallbackCompiledDefinitions,
-            stateProxyModeKey,
-            stateProxyEligibility: sharedStateProxyEligibility
+            compiledDefinitions: sharedCompiledDefinitions
         };
     }
     recomputeCurrentStatePatch() {
@@ -10871,11 +9780,9 @@ class Graphic extends Node {
             return;
         }
         const stateResolveBaseAttrs = this.getStateResolveBaseAttrs();
-        const stateModel = this.createStateModel(stateResolveBaseAttrs);
-        const transition = stateModel.useStates(this.currentStates);
+        const transition = this.resolveUseStatesTransition(this.currentStates, stateResolveBaseAttrs);
         const effectiveStates = (_b = transition.effectiveStates) !== null && _b !== void 0 ? _b : transition.states;
-        const resolvedStateAttrs = this.stateEngine && this.compiledStateDefinitions
-            ? Object.assign({}, this.stateEngine.resolvedPatch) : this.getStateStyleResolver(this.stateMergeMode).resolve(stateResolveBaseAttrs, this.states, this.stateProxy, transition.states, this.stateSort);
+        const resolvedStateAttrs = this.stateEngine && this.compiledStateDefinitions ? Object.assign({}, this.stateEngine.resolvedPatch) : {};
         this.currentStates = transition.states;
         this.effectiveStates = [...effectiveStates];
         this.resolvedStatePatch = resolvedStateAttrs;
@@ -10984,19 +9891,12 @@ class Graphic extends Node {
         return category | nextCategory;
     }
     submitUpdateByCategory(category, forceUpdateTag = false) {
-        var _a;
         if (forceUpdateTag) {
             this.addUpdateShapeAndBoundsTag();
             this.addUpdatePositionTag();
             this.addUpdateLayoutTag();
             return;
         }
-        if (category !== UpdateCategory.NONE) {
-            const stage = this.stage;
-            if (stage) {
-                (_a = getActiveStageStatePerfMonitor(stage)) === null || _a === void 0 ? void 0 : _a.recordCategory(category);
-            }
-        }
         if ((category & BROAD_UPDATE_CATEGORY) === BROAD_UPDATE_CATEGORY) {
             this.addBroadUpdateTag();
             return;
@@ -11399,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) {
@@ -11949,159 +10850,141 @@ class Graphic extends Node {
         (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.setResolveContext(this, stateResolveBaseAttrs);
         return stateResolveBaseAttrs;
     }
-    createStateModel(stateResolveBaseAttrs = this.getStateResolveBaseAttrs()) {
-        const { compiledDefinitions, stateProxyEligibility, stateProxyModeKey } = this.resolveEffectiveCompiledDefinitions();
+    ensureStateEngine(stateResolveBaseAttrs = this.getStateResolveBaseAttrs()) {
+        const { compiledDefinitions } = this.resolveEffectiveCompiledDefinitions();
         this.compiledStateDefinitions = compiledDefinitions;
         if (!compiledDefinitions) {
             this.stateEngine = undefined;
             this.stateEngineCompiledDefinitions = undefined;
-            this.stateEngineStateProxyModeKey = undefined;
         }
         else if (!this.stateEngine ||
             this.stateEngineCompiledDefinitions !== compiledDefinitions ||
-            this.stateEngineStateProxy !== this.stateProxy ||
             this.stateEngineStateSort !== this.stateSort ||
-            this.stateEngineMergeMode !== this.stateMergeMode ||
-            this.stateEngineStateProxyModeKey !== stateProxyModeKey) {
+            this.stateEngineMergeMode !== this.stateMergeMode) {
             this.stateEngine = new StateEngine({
                 compiledDefinitions,
                 stateSort: this.stateSort,
-                stateProxy: this.stateProxy,
-                stateProxyEligibility,
-                states: this.states,
                 mergeMode: this.stateMergeMode
             });
             this.stateEngineCompiledDefinitions = compiledDefinitions;
-            this.stateEngineStateProxy = this.stateProxy;
             this.stateEngineStateSort = this.stateSort;
             this.stateEngineMergeMode = this.stateMergeMode;
-            this.stateEngineStateProxyModeKey = stateProxyModeKey;
         }
         this.syncStateResolveContext(stateResolveBaseAttrs);
-        return new StateModel({
-            states: this.states,
-            currentStates: this.currentStates,
-            stateSort: this.stateSort,
-            stateProxy: this.stateProxy,
-            stateEngine: this.stateEngine
-        });
+        if (this.stateEngine &&
+            this.currentStates &&
+            !this.sameStateNames(this.stateEngine.activeStates, this.currentStates)) {
+            this.stateEngine.applyStates(this.currentStates);
+        }
+        return this.stateEngine;
+    }
+    toGraphicStateTransition(result) {
+        return {
+            changed: result.changed,
+            states: [...result.activeStates],
+            effectiveStates: [...result.effectiveStates]
+        };
+    }
+    sortLocalStates(states) {
+        return this.stateSort ? [...states].sort(this.stateSort) : [...states];
+    }
+    resolveLocalUseStatesTransition(states) {
+        var _a;
+        if (!states.length) {
+            return this.resolveLocalClearStatesTransition();
+        }
+        const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
+        const changed = previousStates.length !== states.length || states.some((stateName, index) => previousStates[index] !== stateName);
+        const nextStates = this.sortLocalStates(states);
+        return {
+            changed,
+            states: changed ? nextStates : [...previousStates]
+        };
     }
-    resolveSimpleLocalStateTransition(states, previousStates) {
+    resolveLocalClearStatesTransition() {
+        return {
+            changed: this.hasState(),
+            states: []
+        };
+    }
+    resolveUseStatesTransition(states, stateResolveBaseAttrs = this.getStateResolveBaseAttrs()) {
+        const stateEngine = this.ensureStateEngine(stateResolveBaseAttrs);
+        return stateEngine
+            ? this.toGraphicStateTransition(stateEngine.applyStates(states))
+            : this.resolveLocalUseStatesTransition(states);
+    }
+    resolveClearStatesTransition() {
+        const stateEngine = this.ensureStateEngine();
+        return stateEngine
+            ? this.toGraphicStateTransition(stateEngine.clearStates())
+            : this.resolveLocalClearStatesTransition();
+    }
+    resolveAddStateTransition(stateName, keepCurrentStates) {
         var _a;
-        if (!this.states ||
-            this.stateProxy ||
-            this.stateSort ||
-            this.stateMergeMode === 'deep' ||
-            this.parent ||
-            ((_a = this.stage) === null || _a === void 0 ? void 0 : _a.rootSharedStateScope) ||
-            this.boundSharedStateScope) {
-            return null;
+        const stateEngine = this.ensureStateEngine();
+        if (stateEngine) {
+            return this.toGraphicStateTransition(stateEngine.addState(stateName, keepCurrentStates));
         }
-        if (states.length === 1) {
-            const stateName = states[0];
-            const hasDefinition = Object.prototype.hasOwnProperty.call(this.states, stateName);
-            const nextStates = [stateName];
-            const changed = !this.sameStateNames(previousStates, nextStates);
-            const resolvedStateAttrs = {};
-            if (hasDefinition) {
-                const attrs = this.states[stateName];
-                if (attrs != null) {
-                    if (!isPlainObjectValue(attrs)) {
-                        return null;
-                    }
-                    const keys = Object.keys(attrs);
-                    for (let keyIndex = 0; keyIndex < keys.length; keyIndex++) {
-                        const key = keys[keyIndex];
-                        if (FULL_STATE_DEFINITION_KEYS.has(key)) {
-                            return null;
-                        }
-                        const attrValue = attrs[key];
-                        resolvedStateAttrs[key] = isPlainObjectValue(attrValue)
-                            ? cloneAttributeValue(attrValue)
-                            : attrValue;
-                    }
-                }
-            }
+        if (this.currentStates &&
+            this.currentStates.includes(stateName) &&
+            (keepCurrentStates || this.currentStates.length === 1)) {
             return {
-                changed,
-                states: nextStates,
-                effectiveStates: nextStates,
-                resolvedStateAttrs
+                changed: false,
+                states: [...this.currentStates]
             };
         }
-        const uniqueStates = Array.from(new Set(states));
-        const withDefinition = [];
-        const withoutDefinition = [];
-        for (let i = 0; i < uniqueStates.length; i++) {
-            const stateName = uniqueStates[i];
-            if (Object.prototype.hasOwnProperty.call(this.states, stateName)) {
-                withDefinition.push(stateName);
-            }
-            else {
-                withoutDefinition.push(stateName);
-            }
+        const nextStates = keepCurrentStates && ((_a = this.currentStates) === null || _a === void 0 ? void 0 : _a.length) ? this.currentStates.concat([stateName]) : [stateName];
+        return this.resolveLocalUseStatesTransition(nextStates);
+    }
+    resolveRemoveStateTransition(stateName) {
+        const stateEngine = this.ensureStateEngine();
+        if (stateEngine) {
+            return this.toGraphicStateTransition(stateEngine.removeState(stateName));
         }
-        withDefinition.sort((left, right) => left.localeCompare(right));
-        const nextStates = withDefinition.concat(withoutDefinition);
-        const changed = !this.sameStateNames(previousStates, nextStates);
-        const resolvedStateAttrs = {};
-        for (let i = 0; i < nextStates.length; i++) {
-            const stateName = nextStates[i];
-            const hasDefinition = Object.prototype.hasOwnProperty.call(this.states, stateName);
-            if (!hasDefinition) {
-                continue;
-            }
-            const attrs = this.states[stateName];
-            if (attrs == null) {
-                continue;
-            }
-            if (!isPlainObjectValue(attrs)) {
-                return null;
-            }
-            const keys = Object.keys(attrs);
-            for (let keyIndex = 0; keyIndex < keys.length; keyIndex++) {
-                const key = keys[keyIndex];
-                if (FULL_STATE_DEFINITION_KEYS.has(key)) {
-                    return null;
-                }
-                const attrValue = attrs[key];
-                resolvedStateAttrs[key] = isPlainObjectValue(attrValue)
-                    ? cloneAttributeValue(attrValue)
-                    : attrValue;
-            }
+        if (!this.currentStates) {
+            return {
+                changed: false,
+                states: []
+            };
         }
-        return {
-            changed,
-            states: nextStates,
-            effectiveStates: nextStates,
-            resolvedStateAttrs
-        };
+        const filter = Array.isArray(stateName) ? (s) => !stateName.includes(s) : (s) => s !== stateName;
+        const nextStates = this.currentStates.filter(filter);
+        if (nextStates.length === this.currentStates.length) {
+            return {
+                changed: false,
+                states: [...this.currentStates]
+            };
+        }
+        return this.resolveLocalUseStatesTransition(nextStates);
     }
-    resolveGraphicStateTransition(states, previousStates, forceResolverRefresh = false) {
-        var _a, _b;
-        let transition = this.resolveSimpleLocalStateTransition(states, previousStates);
-        const isSimpleLocalTransition = !!transition;
-        let resolvedStateAttrs;
-        if (transition) {
-            resolvedStateAttrs = transition.resolvedStateAttrs;
+    resolveToggleStateTransition(stateName) {
+        const stateEngine = this.ensureStateEngine();
+        if (stateEngine) {
+            return this.toGraphicStateTransition(stateEngine.toggleState(stateName));
         }
-        else {
-            const stateResolveBaseAttrs = this.getStateResolveBaseAttrs();
-            const stateModel = this.createStateModel(stateResolveBaseAttrs);
-            if (forceResolverRefresh) {
-                (_a = this.stateEngine) === null || _a === void 0 ? void 0 : _a.invalidateResolverCache();
-            }
-            transition = stateModel.useStates(states);
-            resolvedStateAttrs =
-                this.stateEngine && this.compiledStateDefinitions
-                    ? Object.assign({}, this.stateEngine.resolvedPatch) : this.getStateStyleResolver(this.stateMergeMode).resolve(stateResolveBaseAttrs, this.states, this.stateProxy, transition.states, this.stateSort);
+        if (this.hasState(stateName)) {
+            return this.resolveRemoveStateTransition(stateName);
         }
-        const effectiveStates = (_b = transition.effectiveStates) !== null && _b !== void 0 ? _b : transition.states;
+        const nextStates = this.currentStates ? this.currentStates.slice() : [];
+        nextStates.push(stateName);
+        return this.resolveLocalUseStatesTransition(nextStates);
+    }
+    resolveGraphicStateTransition(states, forceResolverRefresh = false) {
+        var _a;
+        const stateResolveBaseAttrs = this.getStateResolveBaseAttrs();
+        const stateEngine = this.ensureStateEngine(stateResolveBaseAttrs);
+        if (forceResolverRefresh) {
+            stateEngine === null || stateEngine === void 0 ? void 0 : stateEngine.invalidateResolverCache();
+        }
+        const transition = stateEngine
+            ? this.toGraphicStateTransition(stateEngine.applyStates(states))
+            : this.resolveLocalUseStatesTransition(states);
+        const resolvedStateAttrs = this.stateEngine && this.compiledStateDefinitions ? Object.assign({}, this.stateEngine.resolvedPatch) : {};
+        const effectiveStates = (_a = transition.effectiveStates) !== null && _a !== void 0 ? _a : transition.states;
         return {
             transition,
             effectiveStates: effectiveStates,
-            resolvedStateAttrs,
-            isSimpleLocalTransition
+            resolvedStateAttrs
         };
     }
     normalizeSetStatesOptions(options) {
@@ -12138,28 +11021,20 @@ class Graphic extends Node {
         var _a;
         const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
         const previousResolvedStatePatch = this.resolvedStatePatch;
-        const { transition, effectiveStates, resolvedStateAttrs, isSimpleLocalTransition } = this.resolveGraphicStateTransition(states, previousStates, true);
+        const { transition, effectiveStates, resolvedStateAttrs } = this.resolveGraphicStateTransition(states, true);
         const patchChanged = !this.sameStatePatches(previousResolvedStatePatch, resolvedStateAttrs);
         if (patchChanged &&
             !this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, false)) {
             return;
         }
         this.currentStates = transition.states;
-        this.effectiveStates = isSimpleLocalTransition ? effectiveStates : [...effectiveStates];
+        this.effectiveStates = [...effectiveStates];
         this.resolvedStatePatch = resolvedStateAttrs;
         this.sharedStateDirty = false;
         this.syncSharedStateActiveRegistrations();
         if (!patchChanged) {
             return;
         }
-        if (this.stage) {
-            const perfMonitor = getActiveStageStatePerfMonitor(this.stage);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('stateCommits');
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordEvent('state-commit', {
-                graphicId: this._uid,
-                targetStates: [...transition.states]
-            });
-        }
         if (hasAnimation && animateSameStatePatchChange) {
             this._syncFinalAttributeFromStaticTruth();
             this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
@@ -12191,10 +11066,10 @@ class Graphic extends Node {
             }
             : undefined;
         if (isClear) {
-            this.getStateTransitionOrchestrator().applyClearTransition(this, attrs, hasAnimation, stateNames, transitionOptions);
+            this.getStateTransitionOrchestrator().applyClearTransition(this, attrs, hasAnimation, transitionOptions);
             return;
         }
-        const plan = this.getStateTransitionOrchestrator().analyzeTransition({}, attrs, stateNames, hasAnimation, {
+        const plan = this.getStateTransitionOrchestrator().analyzeTransition(attrs, hasAnimation, {
             noWorkAnimateAttr: this.getNoWorkAnimateAttr(),
             animateConfig: resolvedAnimateConfig,
             extraAnimateAttrs: extraAnimateAttrs,
@@ -12227,19 +11102,11 @@ class Graphic extends Node {
         });
         stateAnimates.forEach(animate => animate.stop(type));
     }
-    getNormalAttribute(key) {
-        var _a, _b;
-        const value = this.attribute[key];
-        if (this.hasAnyTrackedAnimate()) {
-            return (_a = this.finalAttribute) === null || _a === void 0 ? void 0 : _a[key];
-        }
-        return value !== null && value !== void 0 ? value : (_b = this.finalAttribute) === null || _b === void 0 ? void 0 : _b[key];
-    }
     clearStates(hasAnimation) {
         var _a, _b, _c;
         const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
         const previousResolvedStatePatch = this.resolvedStatePatch;
-        const transition = this.createStateModel().clearStates();
+        const transition = this.resolveClearStatesTransition();
         if (!transition.changed && previousStates.length === 0) {
             this.currentStates = [];
             this.effectiveStates = [];
@@ -12260,14 +11127,6 @@ class Graphic extends Node {
         this.resolvedStatePatch = undefined;
         this.sharedStateDirty = false;
         this.clearSharedStateActiveRegistrations();
-        if (this.stage) {
-            const perfMonitor = getActiveStageStatePerfMonitor(this.stage);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('stateCommits');
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordEvent('state-commit', {
-                graphicId: this._uid,
-                targetStates: []
-            });
-        }
         if (hasAnimation) {
             this._syncFinalAttributeFromStaticTruth();
             this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, true, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
@@ -12286,19 +11145,19 @@ class Graphic extends Node {
         }
     }
     removeState(stateName, hasAnimation) {
-        const transition = this.createStateModel().removeState(stateName);
+        const transition = this.resolveRemoveStateTransition(stateName);
         if (transition.changed) {
             this.useStates(transition.states, hasAnimation);
         }
     }
     toggleState(stateName, hasAnimation) {
-        const transition = this.createStateModel().toggleState(stateName);
+        const transition = this.resolveToggleStateTransition(stateName);
         if (transition.changed) {
             this.useStates(transition.states, hasAnimation);
         }
     }
     addState(stateName, keepCurrentStates, hasAnimation) {
-        const transition = this.createStateModel().addState(stateName, keepCurrentStates);
+        const transition = this.resolveAddStateTransition(stateName, keepCurrentStates);
         if (!transition.changed) {
             return;
         }
@@ -12339,7 +11198,7 @@ class Graphic extends Node {
         }
         const previousStates = (_a = this.currentStates) !== null && _a !== void 0 ? _a : EMPTY_STATE_NAMES;
         const previousResolvedStatePatch = this.resolvedStatePatch;
-        const { transition, effectiveStates, resolvedStateAttrs, isSimpleLocalTransition } = this.resolveGraphicStateTransition(states, previousStates);
+        const { transition, effectiveStates, resolvedStateAttrs } = this.resolveGraphicStateTransition(states);
         if (!transition.changed && this.sameStateNames(previousStates, transition.states)) {
             return;
         }
@@ -12347,18 +11206,10 @@ class Graphic extends Node {
             return;
         }
         this.currentStates = transition.states;
-        this.effectiveStates = isSimpleLocalTransition ? effectiveStates : [...effectiveStates];
+        this.effectiveStates = [...effectiveStates];
         this.resolvedStatePatch = resolvedStateAttrs;
         this.sharedStateDirty = false;
         this.syncSharedStateActiveRegistrations();
-        if (this.stage) {
-            const perfMonitor = getActiveStageStatePerfMonitor(this.stage);
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.incrementCounter('stateCommits');
-            perfMonitor === null || perfMonitor === void 0 ? void 0 : perfMonitor.recordEvent('state-commit', {
-                graphicId: this._uid,
-                targetStates: [...transition.states]
-            });
-        }
         if (hasAnimation) {
             this._syncFinalAttributeFromStaticTruth();
             this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
@@ -12622,12 +11473,10 @@ class Graphic extends Node {
         }
         this.boundSharedStateScope = undefined;
         this.boundSharedStateRevision = undefined;
-        this.localFallbackCompiledDefinitions = undefined;
         this.compiledStateDefinitions = undefined;
         this.compiledStateDefinitionsCacheKey = undefined;
         this.stateEngine = undefined;
         this.stateEngineCompiledDefinitions = undefined;
-        this.stateEngineStateProxyModeKey = undefined;
         this.sharedStateDirty = false;
         this.stage = null;
         this.layer = null;
@@ -14616,23 +13465,15 @@ class Glyph extends Graphic {
             states = states.sort(this.stateSort);
         }
         const stateAttrs = {};
-        const subAttrs = this.subGraphic.map(() => ({}));
         states.forEach(stateName => {
-            var _a;
             const attrs = this.glyphStateProxy ? this.glyphStateProxy(stateName, states) : this.glyphStates[stateName];
             if (attrs) {
                 Object.assign(stateAttrs, attrs.attributes);
-                if ((_a = attrs.subAttributes) === null || _a === void 0 ? void 0 : _a.length) {
-                    subAttrs.forEach((subAttrs, index) => {
-                        Object.assign(subAttrs, attrs.subAttributes[index]);
-                    });
-                }
             }
         });
         if (!this.beforeStateUpdate(stateAttrs, previousStates, states, hasAnimation, false)) {
             return;
         }
-        this.updateNormalAttrs(stateAttrs);
         this.currentStates = states;
         this.applyStateAttrs(stateAttrs, states, hasAnimation);
     }
@@ -14649,7 +13490,6 @@ class Glyph extends Graphic {
         else {
             this.currentStates = [];
         }
-        this.normalAttrs = null;
     }
     clone() {
         const glyph = new Glyph(Object.assign({}, this.attribute));
@@ -17091,7 +15931,6 @@ class Group extends Graphic {
         this.type = 'group';
         this.parent = null;
         this.isContainer = true;
-        this._hasSharedStateDefinitions = false;
         this.numberType = GROUP_NUMBER_TYPE;
         this._childUpdateTag = UpdateTag.UPDATE_BOUNDS;
     }
@@ -17104,7 +15943,6 @@ class Group extends Graphic {
         }
         const previousScope = this.sharedStateScope;
         this._sharedStateDefinitions = value;
-        this._hasSharedStateDefinitions = !!value && Object.keys(value).length > 0;
         this.ensureSharedStateScopeBound();
         if (this.sharedStateScope) {
             setSharedStateScopeLocalDefinitions(this.sharedStateScope, value);
@@ -17249,13 +16087,7 @@ class Group extends Graphic {
     incrementalAppendChild(node) {
         const data = super.appendChild(node);
         if (data) {
-            if (this.stage &&
-                (data.stage !== this.stage || data.layer !== this.layer)) {
-                data.setStage(this.stage, this.layer);
-            }
-            else if (data.onParentSharedStateTreeChanged) {
-                data.onParentSharedStateTreeChanged(this.stage, this.layer);
-            }
+            this.syncChildSharedStateTreeBinding(data);
         }
         this.addUpdateBoundTag();
         this.getGraphicService().onAddIncremental(node, this, this.stage);
@@ -17269,12 +16101,7 @@ class Group extends Graphic {
     }
     _updateChildToStage(child) {
         if (child) {
-            if (this.stage && (child.stage !== this.stage || child.layer !== this.layer)) {
-                child.setStage(this.stage, this.layer);
-            }
-            else if (child.onParentSharedStateTreeChanged) {
-                child.onParentSharedStateTreeChanged(this.stage, this.layer);
-            }
+            this.syncChildSharedStateTreeBinding(child);
         }
         this.addUpdateBoundTag();
         return child;
@@ -17282,13 +16109,8 @@ class Group extends Graphic {
     appendChild(node, addStage = true) {
         const data = super.appendChild(node);
         if (data) {
-            if (addStage &&
-                this.stage &&
-                (data.stage !== this.stage || data.layer !== this.layer)) {
-                data.setStage(this.stage, this.layer);
-            }
-            else if (data.onParentSharedStateTreeChanged) {
-                data.onParentSharedStateTreeChanged(this.stage, this.layer);
+            if (addStage) {
+                this.syncChildSharedStateTreeBinding(data);
             }
         }
         this.addUpdateBoundTag();
@@ -17304,13 +16126,12 @@ class Group extends Graphic {
         return this._updateChildToStage(super.insertInto(newNode, idx));
     }
     removeChild(child, highPerformance = false) {
-        var _a;
         const data = super.removeChild(child);
         if (!data) {
             return data;
         }
         if (highPerformance) {
-            (_a = child.detachStageForRelease) === null || _a === void 0 ? void 0 : _a.call(child);
+            child.detachStageForRelease();
             return data;
         }
         this.getGraphicService().onRemove(child);
@@ -17335,7 +16156,7 @@ class Group extends Graphic {
     setStage(stage, layer) {
         var _a, _b, _c, _d, _e, _f;
         const graphicService = (_c = (_a = stage === null || stage === void 0 ? void 0 : stage.graphicService) !== null && _a !== void 0 ? _a : (_b = this.stage) === null || _b === void 0 ? void 0 : _b.graphicService) !== null && _c !== void 0 ? _c : application.graphicService;
-        const needsSharedStateTreeSync = this._hasSharedStateDefinitions ||
+        const needsSharedStateTreeSync = this.hasSharedStateDefinitions() ||
             this.sharedStateScope ||
             ((_d = this.currentStates) === null || _d === void 0 ? void 0 : _d.length) ||
             this.boundSharedStateScope ||
@@ -17351,9 +16172,7 @@ class Group extends Graphic {
             this.setStageToShadowRoot(stage, layer);
             this._onSetStage && this._onSetStage(this, stage, layer);
             (_f = graphicService === null || graphicService === void 0 ? void 0 : graphicService.onSetStage) === null || _f === void 0 ? void 0 : _f.call(graphicService, this, stage);
-            this.forEachChildren(item => {
-                item.setStage(stage, this.layer);
-            });
+            this.notifyChildrenSharedStateTreeChanged();
             return;
         }
         const layerChanged = this.layer !== layer;
@@ -17366,11 +16185,7 @@ class Group extends Graphic {
             this.notifyChildrenSharedStateTreeChanged();
         }
         else if (layerChanged) {
-            this.forEachChildren(item => {
-                if (item.onParentSharedStateTreeChanged) {
-                    item.onParentSharedStateTreeChanged(stage, this.layer);
-                }
-            });
+            this.notifyChildrenSharedStateTreeChanged();
         }
     }
     addUpdatePositionTag() {
@@ -17442,8 +16257,7 @@ class Group extends Graphic {
         super.detachStageForRelease();
         this.sharedStateScope = undefined;
         this.forEachChildren((item) => {
-            var _a;
-            (_a = item.detachStageForRelease) === null || _a === void 0 ? void 0 : _a.call(item);
+            item.detachStageForRelease();
         });
     }
     ensureSharedStateScopeBound() {
@@ -17457,7 +16271,6 @@ class Group extends Graphic {
             this.sharedStateScope = createGroupSharedStateScope(this, parentScope, this._sharedStateDefinitions);
             return;
         }
-        this.sharedStateScope.ownerGroup = this;
         this.sharedStateScope.ownerStage = this.stage;
         setSharedStateScopeParent(this.sharedStateScope, parentScope);
         if (this.sharedStateScope.localStateDefinitions !== this._sharedStateDefinitions) {
@@ -17465,15 +16278,16 @@ class Group extends Graphic {
         }
     }
     hasSharedStateDefinitions() {
-        return this._hasSharedStateDefinitions;
+        return !!this._sharedStateDefinitions && Object.keys(this._sharedStateDefinitions).length > 0;
     }
     notifyChildrenSharedStateTreeChanged() {
         this.forEachChildren(item => {
-            if (item.onParentSharedStateTreeChanged) {
-                item.onParentSharedStateTreeChanged(this.stage, this.layer);
-            }
+            this.syncChildSharedStateTreeBinding(item);
         });
     }
+    syncChildSharedStateTreeBinding(child) {
+        child.onParentSharedStateTreeChanged(this.stage, this.layer);
+    }
     onParentSharedStateTreeChanged(stage, layer) {
         var _a;
         if (this.stage !== stage || this.layer !== layer) {
@@ -17974,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) {
@@ -19574,11 +18379,6 @@ class RendererRegistry {
         this.entries.set(key, renderer);
         this.cache.delete(key);
     }
-    registerMany(entries) {
-        for (const [key, renderer] of entries) {
-            this.register(key, renderer);
-        }
-    }
     get(key) {
         if (this.cache.has(key)) {
             return this.cache.get(key);
@@ -19609,11 +18409,6 @@ class PickerRegistry {
     register(key, picker) {
         this.entries.set(key, picker);
     }
-    registerMany(entries) {
-        for (const [key, picker] of entries) {
-            this.register(key, picker);
-        }
-    }
     get(key) {
         return this.entries.get(key);
     }
@@ -19656,11 +18451,6 @@ class ContributionRegistry {
         current.push(contribution);
         this.entries.set(key, current);
     }
-    registerMany(entries) {
-        for (const [key, contribution] of entries) {
-            this.register(key, contribution);
-        }
-    }
     get(key) {
         var _a;
         return [...((_a = this.entries.get(key)) !== null && _a !== void 0 ? _a : [])];
@@ -19685,13 +18475,12 @@ const EMPTY_AUTO_ENABLE_PROVIDER = {
 };
 class DefaultPluginService {
     constructor(autoEnablePlugins = EMPTY_AUTO_ENABLE_PROVIDER, deps = {}) {
-        var _a, _b, _c;
+        var _a;
         this.autoEnablePlugins = autoEnablePlugins;
         this.onStartupFinishedPlugin = [];
         this.onRegisterPlugin = [];
         this.actived = false;
         this.pluginRegistry = (_a = deps.pluginRegistry) !== null && _a !== void 0 ? _a : new PluginRegistry();
-        this.autoEnablePlugins = (_c = (_b = deps.autoEnablePlugins) !== null && _b !== void 0 ? _b : this.autoEnablePlugins) !== null && _c !== void 0 ? _c : EMPTY_AUTO_ENABLE_PROVIDER;
     }
     active(stage, params) {
         this.stage = stage;
@@ -19963,7 +18752,7 @@ class DirtyBoundsPlugin {
         this.key = this.name + this._uid;
         this.dirtyBoundsHooksRegistered = false;
         this.handlePaintOnlyUpdate = (graphic) => {
-            var _a, _b, _c, _d;
+            var _a;
             const stage = this.pluginService.stage;
             if (!(stage && stage === graphic.stage && stage.renderCount)) {
                 return;
@@ -19976,7 +18765,7 @@ class DirtyBoundsPlugin {
             if (ownerBounds && !ownerBounds.empty()) {
                 stage.dirty(ownerBounds);
             }
-            (_b = owner.clearUpdatePaintTag) === null || _b === void 0 ? void 0 : _b.call(owner);
+            owner.clearUpdatePaintTag();
             const shadowRoot = owner.shadowRoot;
             if (!shadowRoot) {
                 return;
@@ -19985,29 +18774,25 @@ class DirtyBoundsPlugin {
             if (shadowBounds && !shadowBounds.empty()) {
                 stage.dirty(shadowBounds);
             }
-            (_d = (_c = shadowRoot).clearUpdatePaintTag) === null || _d === void 0 ? void 0 : _d.call(_c);
+            shadowRoot.clearUpdatePaintTag();
         };
     }
     ensurePaintDirtyBoundsCache(graphic) {
-        var _a, _b;
+        var _a;
         const owner = graphic;
-        const hasLocalBounds = owner._AABBBounds && typeof owner._AABBBounds.empty === 'function' && !owner._AABBBounds.empty();
-        if (!hasLocalBounds && typeof owner.doUpdateAABBBounds === 'function') {
+        if (owner._AABBBounds.empty()) {
             owner.doUpdateAABBBounds(((_a = owner.attribute) === null || _a === void 0 ? void 0 : _a.boundsMode) === 'imprecise');
         }
-        const hasGlobalBounds = owner._globalAABBBounds &&
-            typeof owner._globalAABBBounds.empty === 'function' &&
-            !owner._globalAABBBounds.empty();
-        if (!hasGlobalBounds && typeof owner.tryUpdateGlobalAABBBounds === 'function') {
+        if (!owner._globalAABBBounds || owner._globalAABBBounds.empty()) {
             owner.tryUpdateGlobalAABBBounds();
         }
-        return (_b = owner._globalAABBBounds) !== null && _b !== void 0 ? _b : owner.globalAABBBounds;
+        return owner._globalAABBBounds;
     }
     getRemoveDirtyBounds(graphic) {
         var _a;
         const owner = ((_a = graphic.glyphHost) !== null && _a !== void 0 ? _a : graphic);
         const cachedBounds = owner._globalAABBBounds;
-        if (cachedBounds && typeof cachedBounds.empty === 'function' && !cachedBounds.empty()) {
+        if (cachedBounds && !cachedBounds.empty()) {
             return cachedBounds;
         }
     }
@@ -20107,422 +18892,41 @@ class DirtyBoundsPlugin {
 }
 
 let _isBrowserEnv;
-function initIsBrowserEnv() {
-    if (_isBrowserEnv != null) {
-        return;
-    }
-    try {
-        const canvas = document.createElement('canvas');
-        const ctx = canvas.getContext('2d');
-        _isBrowserEnv = !!(window &&
-            !!canvas.getBoundingClientRect &&
-            !!requestAnimationFrame &&
-            !!window.devicePixelRatio &&
-            ctx &&
-            !!ctx.isPointInPath &&
-            !!ctx.isPointInStroke);
-        if (_isBrowserEnv) {
-            _isBrowserEnv = !!document.createElement;
-        }
-    }
-    catch (err) {
-        _isBrowserEnv = false;
-    }
-}
-function isBrowserEnv() {
-    initIsBrowserEnv();
-    const env = application.global && application.global.env;
-    return env ? env === 'browser' : _isBrowserEnv;
-}
-function isNodeEnv() {
-    initIsBrowserEnv();
-    const env = application.global && application.global.env;
-    return env ? env === 'node' : !_isBrowserEnv;
-}
-function getCurrentEnv() {
-    return isBrowserEnv() ? 'browser' : 'node';
-}
-
-function isRenderableGraphic(graphic) {
-    return !!graphic.stage && graphic.releaseStatus !== 'released';
-}
-function createTargetStatesKey(targetStates) {
-    return targetStates.length ? targetStates.join('|') : '__clear__';
-}
-function createIntentKey(contextOwnerId, configFingerprint, targetStatesKey) {
-    return `${contextOwnerId}:${configFingerprint}:${targetStatesKey}`;
-}
-function hasMeaningfulDeferredConfig(config) {
-    const normalized = normalizeDeferredStateOwnerConfig(config);
-    return !!normalized && (normalized.localEnabled != null || normalized.deferred != null);
-}
-function getGraphicCompiledDefinitions(graphic) {
-    const graphicAny = graphic;
-    if (typeof graphicAny.resolveEffectiveCompiledDefinitions === 'function') {
-        const result = graphicAny.resolveEffectiveCompiledDefinitions();
-        return {
-            compiledDefinitions: result.compiledDefinitions,
-            stateProxyEligibility: result.stateProxyEligibility
-        };
-    }
-    return {};
-}
-function getCurrentStateNames(graphic) {
-    var _a, _b;
-    return (_b = (_a = graphic.currentStates) === null || _a === void 0 ? void 0 : _a.slice()) !== null && _b !== void 0 ? _b : [];
-}
-class StateBatchScheduler {
-    constructor(stage, perfMonitor) {
-        this.stage = stage;
-        this.perfMonitor = perfMonitor;
-        this.jobsByIntentKey = new Map();
-        this.pendingIntentByGraphic = new Map();
-        this.nextJobId = 1;
-        this.runningJobs = new Map();
-    }
-    schedule(graphics, targetStates) {
-        const batchOperation = graphics.length > 1;
-        graphics.forEach(graphic => {
-            const eligibility = this.resolveEligibility(graphic, targetStates, batchOperation, true);
-            if ('reason' in eligibility) {
-                this.removeGraphicFromPending(graphic);
-                if (eligibility.reason !== 'graphic_unavailable') {
-                    this.commitSynchronously(graphic, targetStates);
-                }
-                return;
-            }
-            this.enqueueDeferredIntent(graphic, targetStates, eligibility.context, eligibility.targetStatesKey);
-        });
-    }
-    release() {
-        var _a;
-        this.jobsByIntentKey.forEach(job => {
-            job.status = 'cancelled';
-        });
-        this.jobsByIntentKey.clear();
-        this.pendingIntentByGraphic.clear();
-        this.runningJobs.clear();
-        (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.updateBatchPending(0);
-    }
-    resolveEligibility(graphic, targetStates, batchOperation, recordObservability) {
-        var _a, _b, _c, _d, _e, _f;
-        if (!isRenderableGraphic(graphic)) {
-            if (recordObservability) {
-                (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.recordDeferredIneligible('graphic_unavailable');
-            }
-            return { eligible: false, reason: 'graphic_unavailable' };
-        }
-        if (!batchOperation) {
-            if (recordObservability) {
-                (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.recordDeferredIneligible('non_batch_operation');
-            }
-            return { eligible: false, reason: 'non_batch_operation' };
-        }
-        const context = this.resolveDeferredContext(graphic);
-        if (!context) {
-            if (recordObservability) {
-                (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.recordDeferredIneligible('graphic_unavailable');
-            }
-            return { eligible: false, reason: 'graphic_unavailable' };
-        }
-        if (!context.config.enabled) {
-            const normalizedOwnerConfig = normalizeDeferredStateOwnerConfig(context.contextOwner.deferredStateConfig);
-            const reason = (normalizedOwnerConfig === null || normalizedOwnerConfig === void 0 ? void 0 : normalizedOwnerConfig.localEnabled) === false ? 'context_disabled' : 'config_disabled';
-            if (recordObservability) {
-                (_d = this.perfMonitor) === null || _d === void 0 ? void 0 : _d.recordDeferredIneligible(reason);
-            }
-            return { eligible: false, reason };
-        }
-        const classification = this.classifyGraphicTargetStates(graphic, targetStates);
-        if (classification.reason) {
-            if (recordObservability) {
-                (_e = this.perfMonitor) === null || _e === void 0 ? void 0 : _e.recordDeferredIneligible(classification.reason);
-            }
-            return { eligible: false, reason: classification.reason };
-        }
-        if (classification.category !== UpdateCategory.PAINT) {
-            if (recordObservability) {
-                (_f = this.perfMonitor) === null || _f === void 0 ? void 0 : _f.recordDeferredIneligible('mixed_update_category');
-            }
-            return { eligible: false, reason: 'mixed_update_category' };
-        }
-        return {
-            eligible: true,
-            context,
-            targetStatesKey: createTargetStatesKey(targetStates)
-        };
-    }
-    resolveDeferredContext(graphic) {
-        var _a;
-        const stage = graphic.stage;
-        if (!stage) {
-            return undefined;
-        }
-        let owner = stage;
-        let config = normalizeDeferredStateConfig(undefined);
-        const ownerConfigs = [stage];
-        const parents = [];
-        let parent = graphic.parent;
-        while (parent && parent !== stage) {
-            parents.push(parent);
-            parent = parent.parent;
-        }
-        parents.reverse().forEach(current => ownerConfigs.push(current));
-        ownerConfigs.forEach(current => {
-            const deferredStateConfig = normalizeDeferredStateOwnerConfig(current.deferredStateConfig);
-            if (!deferredStateConfig) {
-                return;
-            }
-            if (deferredStateConfig.deferred) {
-                config = Object.assign(Object.assign({}, config), deferredStateConfig.deferred);
-            }
-            if (deferredStateConfig.localEnabled != null) {
-                config.enabled = deferredStateConfig.localEnabled;
-            }
-            if (hasMeaningfulDeferredConfig(current.deferredStateConfig)) {
-                owner = current;
-            }
-        });
-        const normalized = normalizeDeferredStateConfig(config);
-        return {
-            contextOwner: owner,
-            contextOwnerId: (_a = owner._uid) !== null && _a !== void 0 ? _a : 0,
-            config: normalized,
-            configFingerprint: fingerprintDeferredStateConfig(normalized)
-        };
-    }
-    classifyGraphicTargetStates(graphic, targetStates) {
-        const { compiledDefinitions, stateProxyEligibility } = getGraphicCompiledDefinitions(graphic);
-        const candidateStates = Array.from(new Set([...getCurrentStateNames(graphic), ...targetStates]));
-        let category = UpdateCategory.NONE;
-        candidateStates.forEach(stateName => {
-            if (stateProxyEligibility === null || stateProxyEligibility === void 0 ? void 0 : stateProxyEligibility(stateName)) {
-                category = UpdateCategory.NONE;
-                return;
-            }
-            const definition = compiledDefinitions === null || compiledDefinitions === void 0 ? void 0 : compiledDefinitions.get(stateName);
-            if (!definition) {
-                return;
-            }
-            if (definition.hasResolver && definition.affectedKeys.size === 0) {
-                category = UpdateCategory.NONE;
-                return;
-            }
-            category |= classifyAffectedKeys(definition.affectedKeys);
-        });
-        if (candidateStates.some(stateName => stateProxyEligibility === null || stateProxyEligibility === void 0 ? void 0 : stateProxyEligibility(stateName)) ||
-            candidateStates.some(stateName => {
-                const definition = compiledDefinitions === null || compiledDefinitions === void 0 ? void 0 : compiledDefinitions.get(stateName);
-                return !!(definition === null || definition === void 0 ? void 0 : definition.hasResolver) && definition.affectedKeys.size === 0;
-            })) {
-            return {
-                category: UpdateCategory.NONE,
-                reason: 'resolver_unstable_keys'
-            };
-        }
-        return {
-            category: category === UpdateCategory.NONE ? UpdateCategory.PAINT : category
-        };
-    }
-    enqueueDeferredIntent(graphic, targetStates, context, targetStatesKey) {
-        var _a, _b, _c, _d, _e, _f;
-        const nextIntentKey = createIntentKey(context.contextOwnerId, context.configFingerprint, targetStatesKey);
-        const prevIntentKey = this.pendingIntentByGraphic.get(graphic);
-        if (prevIntentKey === nextIntentKey) {
-            (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.incrementCounter('deferredJobsCoalesced');
-            return;
-        }
-        if (prevIntentKey) {
-            this.removeGraphicFromIntentJob(graphic, prevIntentKey);
-        }
-        let job = this.jobsByIntentKey.get(nextIntentKey);
-        if (!job) {
-            job = {
-                id: this.nextJobId++,
-                kind: 'apply_states',
-                intentKey: nextIntentKey,
-                status: 'pending',
-                targetStates: [...targetStates],
-                targetStatesKey,
-                pendingGraphics: new Set(),
-                orderedGraphics: [],
-                config: context.config,
-                contextOwner: context.contextOwner,
-                contextOwnerId: context.contextOwnerId,
-                configFingerprint: context.configFingerprint,
-                createdAt: Date.now(),
-                processedCount: 0
-            };
-            this.jobsByIntentKey.set(nextIntentKey, job);
-            (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.incrementCounter('deferredJobsCreated');
-            (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.updateBatchPending(this.jobsByIntentKey.size);
-        }
-        else {
-            (_d = this.perfMonitor) === null || _d === void 0 ? void 0 : _d.incrementCounter('deferredJobsCoalesced');
-        }
-        if (!job.pendingGraphics.has(graphic)) {
-            job.pendingGraphics.add(graphic);
-            job.orderedGraphics.push(graphic);
-            this.pendingIntentByGraphic.set(graphic, nextIntentKey);
-            (_e = this.perfMonitor) === null || _e === void 0 ? void 0 : _e.recordAllocation('batchEntriesCreated');
-            (_f = this.perfMonitor) === null || _f === void 0 ? void 0 : _f.updateMaxGraphicsInJob(job.pendingGraphics.size);
-        }
-        this.ensureJobRunning(job);
-    }
-    removeGraphicFromPending(graphic) {
-        const prevIntentKey = this.pendingIntentByGraphic.get(graphic);
-        if (!prevIntentKey) {
-            return;
-        }
-        this.removeGraphicFromIntentJob(graphic, prevIntentKey);
-    }
-    removeGraphicFromIntentJob(graphic, intentKey) {
-        var _a, _b, _c;
-        const job = this.jobsByIntentKey.get(intentKey);
-        if (!job) {
-            this.pendingIntentByGraphic.delete(graphic);
-            return;
-        }
-        job.pendingGraphics.delete(graphic);
-        if (this.pendingIntentByGraphic.get(graphic) === intentKey) {
-            this.pendingIntentByGraphic.delete(graphic);
-        }
-        if (job.pendingGraphics.size === 0 && job.status !== 'completed') {
-            job.status = 'cancelled';
-            this.jobsByIntentKey.delete(intentKey);
-            (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.incrementCounter('deferredJobsCancelled');
-            (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.recordEvent('deferred-job-cancel', {
-                intentKey,
-                jobId: job.id
-            });
-            (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.updateBatchPending(this.jobsByIntentKey.size);
-        }
-    }
-    ensureJobRunning(job) {
-        if (this.runningJobs.has(job.intentKey)) {
-            return;
-        }
-        const runner = this.runJob(job).then(() => {
-            this.runningJobs.delete(job.intentKey);
-        }, () => {
-            this.runningJobs.delete(job.intentKey);
-        });
-        this.runningJobs.set(job.intentKey, runner);
-    }
-    runJob(job) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (job.status === 'cancelled') {
-                return;
-            }
-            yield this.waitForNextFrame();
-            if (job.status === 'cancelled') {
-                return;
-            }
-            job.status = 'running';
-            (_a = this.perfMonitor) === null || _a === void 0 ? void 0 : _a.recordEvent('deferred-job-start', {
-                intentKey: job.intentKey,
-                jobId: job.id
-            });
-            let index = 0;
-            let frameStart = performance.now();
-            let processedInFrame = 0;
-            let committedInSlice = 0;
-            while (index < job.orderedGraphics.length) {
-                if (job.status === 'cancelled') {
-                    return;
-                }
-                if (processedInFrame > 0 &&
-                    (processedInFrame >= job.config.maxGraphicsPerFrame || performance.now() - frameStart >= job.config.frameBudget)) {
-                    (_b = this.perfMonitor) === null || _b === void 0 ? void 0 : _b.incrementCounter('deferredBudgetYields');
-                    (_c = this.perfMonitor) === null || _c === void 0 ? void 0 : _c.recordCost('batchSlice', performance.now() - frameStart);
-                    (_d = this.perfMonitor) === null || _d === void 0 ? void 0 : _d.recordEvent('deferred-job-yield', {
-                        intentKey: job.intentKey,
-                        jobId: job.id,
-                        processedInFrame
-                    });
-                    if (committedInSlice > 0) {
-                        this.stage.renderNextFrame();
-                    }
-                    yield this.waitForNextFrame();
-                    frameStart = performance.now();
-                    processedInFrame = 0;
-                    committedInSlice = 0;
-                }
-                const graphic = job.orderedGraphics[index++];
-                if (!job.pendingGraphics.has(graphic)) {
-                    continue;
-                }
-                if (!isRenderableGraphic(graphic)) {
-                    job.pendingGraphics.delete(graphic);
-                    if (this.pendingIntentByGraphic.get(graphic) === job.intentKey) {
-                        this.pendingIntentByGraphic.delete(graphic);
-                    }
-                    continue;
-                }
-                if (this.pendingIntentByGraphic.get(graphic) !== job.intentKey) {
-                    job.pendingGraphics.delete(graphic);
-                    continue;
-                }
-                const nextEligibility = this.resolveEligibility(graphic, job.targetStates, true, false);
-                if (!nextEligibility.eligible) {
-                    job.pendingGraphics.delete(graphic);
-                    this.pendingIntentByGraphic.delete(graphic);
-                    this.commitSynchronously(graphic, job.targetStates);
-                    continue;
-                }
-                const nextIntentKey = createIntentKey(nextEligibility.context.contextOwnerId, nextEligibility.context.configFingerprint, nextEligibility.targetStatesKey);
-                if (nextIntentKey !== job.intentKey) {
-                    job.pendingGraphics.delete(graphic);
-                    this.pendingIntentByGraphic.delete(graphic);
-                    this.enqueueDeferredIntent(graphic, job.targetStates, nextEligibility.context, nextEligibility.targetStatesKey);
-                    continue;
-                }
-                this.commitSynchronously(graphic, job.targetStates);
-                job.pendingGraphics.delete(graphic);
-                this.pendingIntentByGraphic.delete(graphic);
-                job.processedCount += 1;
-                processedInFrame += 1;
-                committedInSlice += 1;
-                (_e = this.perfMonitor) === null || _e === void 0 ? void 0 : _e.incrementCounter('deferredGraphicsCommitted');
-            }
-            if (processedInFrame > 0) {
-                (_f = this.perfMonitor) === null || _f === void 0 ? void 0 : _f.recordCost('batchSlice', performance.now() - frameStart);
-                this.stage.renderNextFrame();
-            }
-            if (job.pendingGraphics.size === 0 && this.jobsByIntentKey.get(job.intentKey) === job) {
-                job.status = 'completed';
-                this.jobsByIntentKey.delete(job.intentKey);
-                (_g = this.perfMonitor) === null || _g === void 0 ? void 0 : _g.incrementCounter('deferredJobsCompleted');
-                (_h = this.perfMonitor) === null || _h === void 0 ? void 0 : _h.recordEvent('deferred-job-complete', {
-                    intentKey: job.intentKey,
-                    jobId: job.id,
-                    processedCount: job.processedCount
-                });
-                (_j = this.perfMonitor) === null || _j === void 0 ? void 0 : _j.updateBatchPending(this.jobsByIntentKey.size);
-            }
-        });
+function initIsBrowserEnv() {
+    if (_isBrowserEnv != null) {
+        return;
     }
-    waitForNextFrame() {
-        const stageGlobal = this.stage.global;
-        if (stageGlobal === null || stageGlobal === void 0 ? void 0 : stageGlobal.getSpecifiedPerformanceRAF) {
-            return stageGlobal.getSpecifiedPerformanceRAF(this.stage.rafId).wait();
+    try {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        _isBrowserEnv = !!(window &&
+            !!canvas.getBoundingClientRect &&
+            !!requestAnimationFrame &&
+            !!window.devicePixelRatio &&
+            ctx &&
+            !!ctx.isPointInPath &&
+            !!ctx.isPointInStroke);
+        if (_isBrowserEnv) {
+            _isBrowserEnv = !!document.createElement;
         }
-        return new Promise(resolve => {
-            stageGlobal === null || stageGlobal === void 0 ? void 0 : stageGlobal.getSpecifiedRequestAnimationFrame(this.stage.rafId)(() => resolve());
-        });
     }
-    commitSynchronously(graphic, targetStates) {
-        if (!isRenderableGraphic(graphic)) {
-            return;
-        }
-        if (!targetStates.length) {
-            graphic.clearStates(false);
-            return;
-        }
-        graphic.useStates(targetStates, false);
+    catch (err) {
+        _isBrowserEnv = false;
     }
 }
+function isBrowserEnv() {
+    initIsBrowserEnv();
+    const env = application.global && application.global.env;
+    return env ? env === 'browser' : _isBrowserEnv;
+}
+function isNodeEnv() {
+    initIsBrowserEnv();
+    const env = application.global && application.global.env;
+    return env ? env === 'node' : !_isBrowserEnv;
+}
+function getCurrentEnv() {
+    return isBrowserEnv() ? 'browser' : 'node';
+}
 
 const DefaultConfig = {
     WIDTH: 500,
@@ -20704,14 +19108,12 @@ class Stage extends Group {
         this.theme.onStateDefinitionsChange = () => {
             var _a;
             const definitions = (_a = this.theme) === null || _a === void 0 ? void 0 : _a.stateDefinitions;
-            if (!definitions || !Object.keys(definitions).length) {
-                if (this.rootSharedStateScope) {
-                    setRootSharedStateScopeThemeDefinitions(this.rootSharedStateScope, definitions);
-                    markScopeActiveDescendantsDirty(this.rootSharedStateScope, this);
-                }
+            const rootScope = definitions && Object.keys(definitions).length
+                ? this.ensureRootSharedStateScope(definitions)
+                : this.rootSharedStateScope;
+            if (!rootScope) {
                 return;
             }
-            const rootScope = this.ensureRootSharedStateScope(definitions);
             setRootSharedStateScopeThemeDefinitions(rootScope, definitions);
             markScopeActiveDescendantsDirty(rootScope, this);
         };
@@ -21143,21 +19545,6 @@ class Stage extends Group {
         this.rootSharedStateScope.ownerStage = this;
         return this.rootSharedStateScope;
     }
-    getStateBatchScheduler() {
-        if (!this._stateBatchScheduler) {
-            this._stateBatchScheduler = new StateBatchScheduler(this, ensureStageStatePerfMonitor(this));
-        }
-        return this._stateBatchScheduler;
-    }
-    scheduleStateBatch(graphics, targetStates) {
-        this.getStateBatchScheduler().schedule(graphics, targetStates);
-    }
-    getStatePerfSnapshot() {
-        return ensureStageStatePerfMonitor(this).getSnapshot();
-    }
-    resetStatePerfSnapshot() {
-        ensureStageStatePerfMonitor(this).reset();
-    }
     _doRenderInThisFrame() {
         if (this.releaseStatus === 'released') {
             return;
@@ -21291,8 +19678,7 @@ class Stage extends Group {
         throw new Error('暂不支持');
     }
     release() {
-        var _a, _b, _d, _e;
-        (_a = this._stateBatchScheduler) === null || _a === void 0 ? void 0 : _a.release();
+        var _a, _b, _d;
         super.release();
         this.hooks.beforeRender.unTap('constructor', this.beforeRender);
         this.hooks.afterRender.unTap('constructor', this.afterRender);
@@ -21310,10 +19696,10 @@ class Stage extends Group {
             this.interactiveLayer.release();
         }
         this.window.release();
-        (_b = this._ticker) === null || _b === void 0 ? void 0 : _b.remTimeline(this === null || this === void 0 ? void 0 : this.timeline);
-        (_d = this._ticker) === null || _d === void 0 ? void 0 : _d.removeListener('tick', this.afterTickCb);
+        (_a = this._ticker) === null || _a === void 0 ? void 0 : _a.remTimeline(this === null || this === void 0 ? void 0 : this.timeline);
+        (_b = this._ticker) === null || _b === void 0 ? void 0 : _b.removeListener('tick', this.afterTickCb);
         if (!this.params.ticker) {
-            (_e = this._ticker) === null || _e === void 0 ? void 0 : _e.release();
+            (_d = this._ticker) === null || _d === void 0 ? void 0 : _d.release();
         }
         this.renderService.renderTreeRoots = [];
     }
@@ -27609,18 +25995,12 @@ function createBrowserApp(options = {}) {
 }
 
 class NodeEntry extends BrowserEntry {
-    constructor(options = {}) {
-        super(options);
-    }
 }
 function createNodeApp(options = {}) {
     return new NodeEntry(options);
 }
 
 class MiniappEntry extends BrowserEntry {
-    constructor(options = {}) {
-        super(options);
-    }
 }
 function createMiniappApp(options = {}) {
     return new MiniappEntry(options);
@@ -30038,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') {