@dan-uni/dan-any 1.3.9 → 1.4.1

package/dist/umd/index.umd.min.js

@@ -1232,7 +1232,6 @@
                     if (y < x) return 1;
                     return 0;
                 }
-                var ONLY_ENUMERABLE = void 0;
                 var kStrict = true;
                 var kLoose = false;
                 var kNoIterator = 0;
@@ -1282,8 +1281,8 @@
                     if (val1Tag !== val2Tag) return false;
                     if (Array.isArray(val1)) {
                         if (val1.length !== val2.length) return false;
-                        var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
-                        var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+                        var keys1 = getOwnNonIndexProperties(val1);
+                        var keys2 = getOwnNonIndexProperties(val2);
                         if (keys1.length !== keys2.length) return false;
                         return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
                     }
@@ -1300,8 +1299,8 @@
                         if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
                             if (!areSimilarFloatArrays(val1, val2)) return false;
                         } else if (!areSimilarTypedArrays(val1, val2)) return false;
-                        var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
-                        var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+                        var _keys = getOwnNonIndexProperties(val1);
+                        var _keys2 = getOwnNonIndexProperties(val2);
                         if (_keys.length !== _keys2.length) return false;
                         return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
                     } else if (isSet(val1)) {
@@ -14049,10 +14048,10 @@
                     if ('object' == typeof value && null !== value) return {
                         enabled: false !== value.enabled,
                         maxEntitySize: Math.max(1, value.maxEntitySize ?? 10000),
-                        maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 10),
-                        maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? 1000),
+                        maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 10000),
+                        maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? 1 / 0),
                         maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 100000),
-                        maxEntityCount: Math.max(1, value.maxEntityCount ?? 100),
+                        maxEntityCount: Math.max(1, value.maxEntityCount ?? 1000),
                         allowedTags: value.allowedTags ?? null,
                         tagFilter: value.tagFilter ?? null
                     };
@@ -14085,6 +14084,7 @@
                     for (const { value, name } of propertyNameOptions)if (value) validatePropertyName(value, name);
                     if (null === built.onDangerousProperty) built.onDangerousProperty = defaultOnDangerousProperty;
                     built.processEntities = normalizeProcessEntities(built.processEntities);
+                    built.unpairedTagsSet = new Set(built.unpairedTags);
                     if (built.stopNodes && Array.isArray(built.stopNodes)) built.stopNodes = built.stopNodes.map((node)=>{
                         if ('string' == typeof node && node.startsWith('*.')) return '..' + node.substring(2);
                         return node;
@@ -14448,24 +14448,72 @@
                     };
                     return ()=>false;
                 }
-                const MUTATING_METHODS = new Set([
-                    'push',
-                    'pop',
-                    'reset',
-                    'updateCurrent',
-                    'restore'
-                ]);
+                class MatcherView {
+                    constructor(matcher){
+                        this._matcher = matcher;
+                    }
+                    get separator() {
+                        return this._matcher.separator;
+                    }
+                    getCurrentTag() {
+                        const path = this._matcher.path;
+                        return path.length > 0 ? path[path.length - 1].tag : void 0;
+                    }
+                    getCurrentNamespace() {
+                        const path = this._matcher.path;
+                        return path.length > 0 ? path[path.length - 1].namespace : void 0;
+                    }
+                    getAttrValue(attrName) {
+                        const path = this._matcher.path;
+                        if (0 === path.length) return;
+                        return path[path.length - 1].values?.[attrName];
+                    }
+                    hasAttr(attrName) {
+                        const path = this._matcher.path;
+                        if (0 === path.length) return false;
+                        const current = path[path.length - 1];
+                        return void 0 !== current.values && attrName in current.values;
+                    }
+                    getPosition() {
+                        const path = this._matcher.path;
+                        if (0 === path.length) return -1;
+                        return path[path.length - 1].position ?? 0;
+                    }
+                    getCounter() {
+                        const path = this._matcher.path;
+                        if (0 === path.length) return -1;
+                        return path[path.length - 1].counter ?? 0;
+                    }
+                    getIndex() {
+                        return this.getPosition();
+                    }
+                    getDepth() {
+                        return this._matcher.path.length;
+                    }
+                    toString(separator, includeNamespace = true) {
+                        return this._matcher.toString(separator, includeNamespace);
+                    }
+                    toArray() {
+                        return this._matcher.path.map((n)=>n.tag);
+                    }
+                    matches(expression) {
+                        return this._matcher.matches(expression);
+                    }
+                    matchesAny(exprSet) {
+                        return exprSet.matchesAny(this._matcher);
+                    }
+                }
                 class Matcher {
                     constructor(options = {}){
                         this.separator = options.separator || '.';
                         this.path = [];
                         this.siblingStacks = [];
+                        this._pathStringCache = null;
+                        this._view = new MatcherView(this);
                     }
                     push(tagName, attrValues = null, namespace = null) {
-                        if (this.path.length > 0) {
-                            const prev = this.path[this.path.length - 1];
-                            prev.values = void 0;
-                        }
+                        this._pathStringCache = null;
+                        if (this.path.length > 0) this.path[this.path.length - 1].values = void 0;
                         const currentLevel = this.path.length;
                         if (!this.siblingStacks[currentLevel]) this.siblingStacks[currentLevel] = new Map();
                         const siblings = this.siblingStacks[currentLevel];
@@ -14485,6 +14533,7 @@
                     }
                     pop() {
                         if (0 === this.path.length) return;
+                        this._pathStringCache = null;
                         const node = this.path.pop();
                         if (this.siblingStacks.length > this.path.length + 1) this.siblingStacks.length = this.path.length + 1;
                         return node;
@@ -14503,8 +14552,7 @@
                     }
                     getAttrValue(attrName) {
                         if (0 === this.path.length) return;
-                        const current = this.path[this.path.length - 1];
-                        return current.values?.[attrName];
+                        return this.path[this.path.length - 1].values?.[attrName];
                     }
                     hasAttr(attrName) {
                         if (0 === this.path.length) return false;
@@ -14527,15 +14575,20 @@
                     }
                     toString(separator, includeNamespace = true) {
                         const sep = separator || this.separator;
-                        return this.path.map((n)=>{
-                            if (includeNamespace && n.namespace) return `${n.namespace}:${n.tag}`;
-                            return n.tag;
-                        }).join(sep);
+                        const isDefault = sep === this.separator && true === includeNamespace;
+                        if (isDefault) {
+                            if (null !== this._pathStringCache) return this._pathStringCache;
+                            const result = this.path.map((n)=>n.namespace ? `${n.namespace}:${n.tag}` : n.tag).join(sep);
+                            this._pathStringCache = result;
+                            return result;
+                        }
+                        return this.path.map((n)=>includeNamespace && n.namespace ? `${n.namespace}:${n.tag}` : n.tag).join(sep);
                     }
                     toArray() {
                         return this.path.map((n)=>n.tag);
                     }
                     reset() {
+                        this._pathStringCache = null;
                         this.path = [];
                         this.siblingStacks = [];
                     }
@@ -14547,12 +14600,7 @@
                     }
                     _matchSimple(segments) {
                         if (this.path.length !== segments.length) return false;
-                        for(let i = 0; i < segments.length; i++){
-                            const segment = segments[i];
-                            const node = this.path[i];
-                            const isCurrentNode = i === this.path.length - 1;
-                            if (!this._matchSegment(segment, node, isCurrentNode)) return false;
-                        }
+                        for(let i = 0; i < segments.length; i++)if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) return false;
                         return true;
                     }
                     _matchWithDeepWildcard(segments) {
@@ -14565,19 +14613,15 @@
                                 if (segIdx < 0) return true;
                                 const nextSeg = segments[segIdx];
                                 let found = false;
-                                for(let i = pathIdx; i >= 0; i--){
-                                    const isCurrentNode = i === this.path.length - 1;
-                                    if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {
-                                        pathIdx = i - 1;
-                                        segIdx--;
-                                        found = true;
-                                        break;
-                                    }
+                                for(let i = pathIdx; i >= 0; i--)if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {
+                                    pathIdx = i - 1;
+                                    segIdx--;
+                                    found = true;
+                                    break;
                                 }
                                 if (!found) return false;
                             } else {
-                                const isCurrentNode = pathIdx === this.path.length - 1;
-                                if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) return false;
+                                if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) return false;
                                 pathIdx--;
                                 segIdx--;
                             }
@@ -14593,8 +14637,7 @@
                             if (!isCurrentNode) return false;
                             if (!node.values || !(segment.attrName in node.values)) return false;
                             if (void 0 !== segment.attrValue) {
-                                const actualValue = node.values[segment.attrName];
-                                if (String(actualValue) !== String(segment.attrValue)) return false;
+                                if (String(node.values[segment.attrName]) !== String(segment.attrValue)) return false;
                             }
                         }
                         if (void 0 !== segment.position) {
@@ -14603,12 +14646,13 @@
                             if ('first' === segment.position && 0 !== counter) return false;
                             if ('odd' === segment.position && counter % 2 !== 1) return false;
                             if ('even' === segment.position && counter % 2 !== 0) return false;
-                            else if ('nth' === segment.position) {
-                                if (counter !== segment.positionValue) return false;
-                            }
+                            else if ('nth' === segment.position && counter !== segment.positionValue) return false;
                         }
                         return true;
                     }
+                    matchesAny(exprSet) {
+                        return exprSet.matchesAny(this);
+                    }
                     snapshot() {
                         return {
                             path: this.path.map((node)=>({
@@ -14618,39 +14662,22 @@
                         };
                     }
                     restore(snapshot) {
+                        this._pathStringCache = null;
                         this.path = snapshot.path.map((node)=>({
                                 ...node
                             }));
                         this.siblingStacks = snapshot.siblingStacks.map((map)=>new Map(map));
                     }
                     readOnly() {
-                        const self1 = this;
-                        return new Proxy(self1, {
-                            get (target, prop, receiver) {
-                                if (MUTATING_METHODS.has(prop)) return ()=>{
-                                    throw new TypeError(`Cannot call '${prop}' on a read-only Matcher. Obtain a writable instance to mutate state.`);
-                                };
-                                const value = Reflect.get(target, prop, receiver);
-                                if ('path' === prop || 'siblingStacks' === prop) return Object.freeze(Array.isArray(value) ? value.map((item)=>item instanceof Map ? Object.freeze(new Map(item)) : Object.freeze({
-                                        ...item
-                                    })) : value);
-                                if ('function' == typeof value) return value.bind(target);
-                                return value;
-                            },
-                            set (_target, prop) {
-                                throw new TypeError(`Cannot set property '${String(prop)}' on a read-only Matcher.`);
-                            },
-                            deleteProperty (_target, prop) {
-                                throw new TypeError(`Cannot delete property '${String(prop)}' from a read-only Matcher.`);
-                            }
-                        });
+                        return this._view;
                     }
                 }
                 class Expression {
-                    constructor(pattern, options = {}){
+                    constructor(pattern, options = {}, data){
                         this.pattern = pattern;
                         this.separator = options.separator || '.';
                         this.segments = this._parse(pattern);
+                        this.data = data;
                         this._hasDeepWildcard = this.segments.some((seg)=>'deep-wildcard' === seg.type);
                         this._hasAttributeCondition = this.segments.some((seg)=>void 0 !== seg.attrName);
                         this._hasPositionSelector = this.segments.some((seg)=>void 0 !== seg.position);
@@ -14752,6 +14779,71 @@
                         return this.pattern;
                     }
                 }
+                class ExpressionSet {
+                    constructor(){
+                        this._byDepthAndTag = new Map();
+                        this._wildcardByDepth = new Map();
+                        this._deepWildcards = [];
+                        this._patterns = new Set();
+                        this._sealed = false;
+                    }
+                    add(expression) {
+                        if (this._sealed) throw new TypeError('ExpressionSet is sealed. Create a new ExpressionSet to add more expressions.');
+                        if (this._patterns.has(expression.pattern)) return this;
+                        this._patterns.add(expression.pattern);
+                        if (expression.hasDeepWildcard()) {
+                            this._deepWildcards.push(expression);
+                            return this;
+                        }
+                        const depth = expression.length;
+                        const lastSeg = expression.segments[expression.segments.length - 1];
+                        const tag = lastSeg?.tag;
+                        if (tag && '*' !== tag) {
+                            const key = `${depth}:${tag}`;
+                            if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);
+                            this._byDepthAndTag.get(key).push(expression);
+                        } else {
+                            if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);
+                            this._wildcardByDepth.get(depth).push(expression);
+                        }
+                        return this;
+                    }
+                    addAll(expressions) {
+                        for (const expr of expressions)this.add(expr);
+                        return this;
+                    }
+                    has(expression) {
+                        return this._patterns.has(expression.pattern);
+                    }
+                    get size() {
+                        return this._patterns.size;
+                    }
+                    seal() {
+                        this._sealed = true;
+                        return this;
+                    }
+                    get isSealed() {
+                        return this._sealed;
+                    }
+                    matchesAny(matcher) {
+                        return null !== this.findMatch(matcher);
+                    }
+                    findMatch(matcher) {
+                        const depth = matcher.getDepth();
+                        const tag = matcher.getCurrentTag();
+                        const exactKey = `${depth}:${tag}`;
+                        const exactBucket = this._byDepthAndTag.get(exactKey);
+                        if (exactBucket) {
+                            for(let i = 0; i < exactBucket.length; i++)if (matcher.matches(exactBucket[i])) return exactBucket[i];
+                        }
+                        const wildcardBucket = this._wildcardByDepth.get(depth);
+                        if (wildcardBucket) {
+                            for(let i = 0; i < wildcardBucket.length; i++)if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];
+                        }
+                        for(let i = 0; i < this._deepWildcards.length; i++)if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];
+                        return null;
+                    }
+                }
                 function extractRawAttributes(prefixedAttrs, options) {
                     if (!prefixedAttrs) return {};
                     const attrs = options.attributesGroupName ? prefixedAttrs[options.attributesGroupName] : prefixedAttrs;
@@ -14857,13 +14949,15 @@
                         this.matcher = new Matcher();
                         this.readonlyMatcher = this.matcher.readOnly();
                         this.isCurrentNodeStopNode = false;
-                        if (this.options.stopNodes && this.options.stopNodes.length > 0) {
-                            this.stopNodeExpressions = [];
-                            for(let i = 0; i < this.options.stopNodes.length; i++){
-                                const stopNodeExp = this.options.stopNodes[i];
-                                if ('string' == typeof stopNodeExp) this.stopNodeExpressions.push(new Expression(stopNodeExp));
-                                else if (stopNodeExp instanceof Expression) this.stopNodeExpressions.push(stopNodeExp);
+                        this.stopNodeExpressionsSet = new ExpressionSet();
+                        const stopNodesOpts = this.options.stopNodes;
+                        if (stopNodesOpts && stopNodesOpts.length > 0) {
+                            for(let i = 0; i < stopNodesOpts.length; i++){
+                                const stopNodeExp = stopNodesOpts[i];
+                                if ('string' == typeof stopNodeExp) this.stopNodeExpressionsSet.add(new Expression(stopNodeExp));
+                                else if (stopNodeExp instanceof Expression) this.stopNodeExpressionsSet.add(stopNodeExp);
                             }
+                            this.stopNodeExpressionsSet.seal();
                         }
                     }
                 }
@@ -14879,18 +14973,19 @@
                     }
                 }
                 function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
+                    const options = this.options;
                     if (void 0 !== val) {
-                        if (this.options.trimValues && !dontTrim) val = val.trim();
+                        if (options.trimValues && !dontTrim) val = val.trim();
                         if (val.length > 0) {
                             if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);
-                            const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
-                            const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
+                            const jPathOrMatcher = options.jPath ? jPath.toString() : jPath;
+                            const newval = options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
                             if (null == newval) return val;
                             {
                                 if (typeof newval !== typeof val || newval !== val) return newval;
-                                if (this.options.trimValues) return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+                                if (options.trimValues) return parseValue(val, options.parseTagValue, options.numberParseOptions);
                                 const trimmedVal = val.trim();
-                                if (trimmedVal === val) return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+                                if (trimmedVal === val) return parseValue(val, options.parseTagValue, options.numberParseOptions);
                                 return val;
                             }
                         }
@@ -14907,46 +15002,53 @@
                 }
                 const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
                 function buildAttributesMap(attrStr, jPath, tagName) {
-                    if (true !== this.options.ignoreAttributes && 'string' == typeof attrStr) {
+                    const options = this.options;
+                    if (true !== options.ignoreAttributes && 'string' == typeof attrStr) {
                         const matches = getAllMatches(attrStr, attrsRegx);
                         const len = matches.length;
                         const attrs = {};
+                        const processedVals = new Array(len);
+                        let hasRawAttrs = false;
                         const rawAttrsForMatcher = {};
                         for(let i = 0; i < len; i++){
                             const attrName = this.resolveNameSpace(matches[i][1]);
                             const oldVal = matches[i][4];
                             if (attrName.length && void 0 !== oldVal) {
-                                let parsedVal = oldVal;
-                                if (this.options.trimValues) parsedVal = parsedVal.trim();
-                                parsedVal = this.replaceEntitiesValue(parsedVal, tagName, this.readonlyMatcher);
-                                rawAttrsForMatcher[attrName] = parsedVal;
+                                let val = oldVal;
+                                if (options.trimValues) val = val.trim();
+                                val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);
+                                processedVals[i] = val;
+                                rawAttrsForMatcher[attrName] = val;
+                                hasRawAttrs = true;
                             }
                         }
-                        if (Object.keys(rawAttrsForMatcher).length > 0 && 'object' == typeof jPath && jPath.updateCurrent) jPath.updateCurrent(rawAttrsForMatcher);
+                        if (hasRawAttrs && 'object' == typeof jPath && jPath.updateCurrent) jPath.updateCurrent(rawAttrsForMatcher);
+                        const jPathStr = options.jPath ? jPath.toString() : this.readonlyMatcher;
+                        let hasAttrs = false;
                         for(let i = 0; i < len; i++){
                             const attrName = this.resolveNameSpace(matches[i][1]);
-                            const jPathStr = this.options.jPath ? jPath.toString() : this.readonlyMatcher;
                             if (this.ignoreAttributesFn(attrName, jPathStr)) continue;
-                            let oldVal = matches[i][4];
-                            let aName = this.options.attributeNamePrefix + attrName;
+                            let aName = options.attributeNamePrefix + attrName;
                             if (attrName.length) {
-                                if (this.options.transformAttributeName) aName = this.options.transformAttributeName(aName);
-                                aName = sanitizeName(aName, this.options);
-                                if (void 0 !== oldVal) {
-                                    if (this.options.trimValues) oldVal = oldVal.trim();
-                                    oldVal = this.replaceEntitiesValue(oldVal, tagName, this.readonlyMatcher);
-                                    const jPathOrMatcher = this.options.jPath ? jPath.toString() : this.readonlyMatcher;
-                                    const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);
+                                if (options.transformAttributeName) aName = options.transformAttributeName(aName);
+                                aName = sanitizeName(aName, options);
+                                if (void 0 !== matches[i][4]) {
+                                    const oldVal = processedVals[i];
+                                    const newVal = options.attributeValueProcessor(attrName, oldVal, jPathStr);
                                     if (null == newVal) attrs[aName] = oldVal;
                                     else if (typeof newVal !== typeof oldVal || newVal !== oldVal) attrs[aName] = newVal;
-                                    else attrs[aName] = parseValue(oldVal, this.options.parseAttributeValue, this.options.numberParseOptions);
-                                } else if (this.options.allowBooleanAttributes) attrs[aName] = true;
+                                    else attrs[aName] = parseValue(oldVal, options.parseAttributeValue, options.numberParseOptions);
+                                    hasAttrs = true;
+                                } else if (options.allowBooleanAttributes) {
+                                    attrs[aName] = true;
+                                    hasAttrs = true;
+                                }
                             }
                         }
-                        if (!Object.keys(attrs).length) return;
-                        if (this.options.attributesGroupName) {
+                        if (!hasAttrs) return;
+                        if (options.attributesGroupName) {
                             const attrCollection = {};
-                            attrCollection[this.options.attributesGroupName] = attrs;
+                            attrCollection[options.attributesGroupName] = attrs;
                             return attrCollection;
                         }
                         return attrs;
@@ -14960,155 +15062,163 @@
                     this.matcher.reset();
                     this.entityExpansionCount = 0;
                     this.currentExpandedLength = 0;
-                    const docTypeReader = new DocTypeReader(this.options.processEntities);
-                    for(let i = 0; i < xmlData.length; i++){
+                    this.docTypeEntitiesKeys = [];
+                    this.lastEntitiesKeys = Object.keys(this.lastEntities);
+                    this.htmlEntitiesKeys = this.options.htmlEntities ? Object.keys(this.htmlEntities) : [];
+                    const options = this.options;
+                    const docTypeReader = new DocTypeReader(options.processEntities);
+                    const xmlLen = xmlData.length;
+                    for(let i = 0; i < xmlLen; i++){
                         const ch = xmlData[i];
-                        if ('<' === ch) if ('/' === xmlData[i + 1]) {
-                            const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
-                            let tagName = xmlData.substring(i + 2, closeIndex).trim();
-                            if (this.options.removeNSPrefix) {
-                                const colonIndex = tagName.indexOf(":");
-                                if (-1 !== colonIndex) tagName = tagName.substr(colonIndex + 1);
-                            }
-                            tagName = transformTagName(this.options.transformTagName, tagName, "", this.options).tagName;
-                            if (currentNode) textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
-                            const lastTagName = this.matcher.getCurrentTag();
-                            if (tagName && -1 !== this.options.unpairedTags.indexOf(tagName)) throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
-                            if (lastTagName && -1 !== this.options.unpairedTags.indexOf(lastTagName)) {
+                        if ('<' === ch) {
+                            const c1 = xmlData.charCodeAt(i + 1);
+                            if (47 === c1) {
+                                const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
+                                let tagName = xmlData.substring(i + 2, closeIndex).trim();
+                                if (options.removeNSPrefix) {
+                                    const colonIndex = tagName.indexOf(":");
+                                    if (-1 !== colonIndex) tagName = tagName.substr(colonIndex + 1);
+                                }
+                                tagName = transformTagName(options.transformTagName, tagName, "", options).tagName;
+                                if (currentNode) textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
+                                const lastTagName = this.matcher.getCurrentTag();
+                                if (tagName && options.unpairedTagsSet.has(tagName)) throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
+                                if (lastTagName && options.unpairedTagsSet.has(lastTagName)) {
+                                    this.matcher.pop();
+                                    this.tagsNodeStack.pop();
+                                }
                                 this.matcher.pop();
-                                this.tagsNodeStack.pop();
-                            }
-                            this.matcher.pop();
-                            this.isCurrentNodeStopNode = false;
-                            currentNode = this.tagsNodeStack.pop();
-                            textData = "";
-                            i = closeIndex;
-                        } else if ('?' === xmlData[i + 1]) {
-                            let tagData = readTagExp(xmlData, i, false, "?>");
-                            if (!tagData) throw new Error("Pi Tag is not closed.");
-                            textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
-                            if (this.options.ignoreDeclaration && "?xml" === tagData.tagName || this.options.ignorePiTags) ;
-                            else {
-                                const childNode = new XmlNode(tagData.tagName);
-                                childNode.add(this.options.textNodeName, "");
-                                if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
-                                this.addChild(currentNode, childNode, this.readonlyMatcher, i);
-                            }
-                            i = tagData.closeIndex + 1;
-                        } else if ('!--' === xmlData.substr(i + 1, 3)) {
-                            const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
-                            if (this.options.commentPropName) {
-                                const comment = xmlData.substring(i + 4, endIndex - 2);
+                                this.isCurrentNodeStopNode = false;
+                                currentNode = this.tagsNodeStack.pop();
+                                textData = "";
+                                i = closeIndex;
+                            } else if (63 === c1) {
+                                let tagData = readTagExp(xmlData, i, false, "?>");
+                                if (!tagData) throw new Error("Pi Tag is not closed.");
                                 textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
-                                currentNode.add(this.options.commentPropName, [
+                                if (options.ignoreDeclaration && "?xml" === tagData.tagName || options.ignorePiTags) ;
+                                else {
+                                    const childNode = new XmlNode(tagData.tagName);
+                                    childNode.add(options.textNodeName, "");
+                                    if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
+                                    this.addChild(currentNode, childNode, this.readonlyMatcher, i);
+                                }
+                                i = tagData.closeIndex + 1;
+                            } else if (33 === c1 && 45 === xmlData.charCodeAt(i + 2) && 45 === xmlData.charCodeAt(i + 3)) {
+                                const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
+                                if (options.commentPropName) {
+                                    const comment = xmlData.substring(i + 4, endIndex - 2);
+                                    textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
+                                    currentNode.add(options.commentPropName, [
+                                        {
+                                            [options.textNodeName]: comment
+                                        }
+                                    ]);
+                                }
+                                i = endIndex;
+                            } else if (33 === c1 && 68 === xmlData.charCodeAt(i + 2)) {
+                                const result = docTypeReader.readDocType(xmlData, i);
+                                this.docTypeEntities = result.entities;
+                                this.docTypeEntitiesKeys = Object.keys(this.docTypeEntities) || [];
+                                i = result.i;
+                            } else if (33 === c1 && 91 === xmlData.charCodeAt(i + 2)) {
+                                const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
+                                const tagExp = xmlData.substring(i + 9, closeIndex);
+                                textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
+                                let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, true, false, true, true);
+                                if (void 0 == val) val = "";
+                                if (options.cdataPropName) currentNode.add(options.cdataPropName, [
                                     {
-                                        [this.options.textNodeName]: comment
+                                        [options.textNodeName]: tagExp
                                     }
                                 ]);
-                            }
-                            i = endIndex;
-                        } else if ('!D' === xmlData.substr(i + 1, 2)) {
-                            const result = docTypeReader.readDocType(xmlData, i);
-                            this.docTypeEntities = result.entities;
-                            i = result.i;
-                        } else if ('![' === xmlData.substr(i + 1, 2)) {
-                            const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
-                            const tagExp = xmlData.substring(i + 9, closeIndex);
-                            textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
-                            let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, true, false, true, true);
-                            if (void 0 == val) val = "";
-                            if (this.options.cdataPropName) currentNode.add(this.options.cdataPropName, [
-                                {
-                                    [this.options.textNodeName]: tagExp
+                                else currentNode.add(options.textNodeName, val);
+                                i = closeIndex + 2;
+                            } else {
+                                let result = readTagExp(xmlData, i, options.removeNSPrefix);
+                                if (!result) {
+                                    const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlLen, i + 50));
+                                    throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
                                 }
-                            ]);
-                            else currentNode.add(this.options.textNodeName, val);
-                            i = closeIndex + 2;
-                        } else {
-                            let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
-                            if (!result) {
-                                const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlData.length, i + 50));
-                                throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
-                            }
-                            let tagName = result.tagName;
-                            const rawTagName = result.rawTagName;
-                            let tagExp = result.tagExp;
-                            let attrExpPresent = result.attrExpPresent;
-                            let closeIndex = result.closeIndex;
-                            ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
-                            if (this.options.strictReservedNames && (tagName === this.options.commentPropName || tagName === this.options.cdataPropName || tagName === this.options.textNodeName || tagName === this.options.attributesGroupName)) throw new Error(`Invalid tag name: ${tagName}`);
-                            if (currentNode && textData) {
-                                if ('!xml' !== currentNode.tagname) textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher, false);
-                            }
-                            const lastTag = currentNode;
-                            if (lastTag && -1 !== this.options.unpairedTags.indexOf(lastTag.tagname)) {
-                                currentNode = this.tagsNodeStack.pop();
-                                this.matcher.pop();
-                            }
-                            let isSelfClosing = false;
-                            if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
-                                isSelfClosing = true;
-                                if ("/" === tagName[tagName.length - 1]) {
-                                    tagName = tagName.substr(0, tagName.length - 1);
-                                    tagExp = tagName;
-                                } else tagExp = tagExp.substr(0, tagExp.length - 1);
-                                attrExpPresent = tagName !== tagExp;
-                            }
-                            let prefixedAttrs = null;
-                            let namespace;
-                            namespace = extractNamespace(rawTagName);
-                            if (tagName !== xmlObj.tagname) this.matcher.push(tagName, {}, namespace);
-                            if (tagName !== tagExp && attrExpPresent) {
-                                prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
-                                if (prefixedAttrs) extractRawAttributes(prefixedAttrs, this.options);
-                            }
-                            if (tagName !== xmlObj.tagname) this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);
-                            const startIndex = i;
-                            if (this.isCurrentNodeStopNode) {
-                                let tagContent = "";
-                                if (isSelfClosing) i = result.closeIndex;
-                                else if (-1 !== this.options.unpairedTags.indexOf(tagName)) i = result.closeIndex;
-                                else {
-                                    const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
-                                    if (!result) throw new Error(`Unexpected end of ${rawTagName}`);
-                                    i = result.i;
-                                    tagContent = result.tagContent;
+                                let tagName = result.tagName;
+                                const rawTagName = result.rawTagName;
+                                let tagExp = result.tagExp;
+                                let attrExpPresent = result.attrExpPresent;
+                                let closeIndex = result.closeIndex;
+                                ({ tagName, tagExp } = transformTagName(options.transformTagName, tagName, tagExp, options));
+                                if (options.strictReservedNames && (tagName === options.commentPropName || tagName === options.cdataPropName || tagName === options.textNodeName || tagName === options.attributesGroupName)) throw new Error(`Invalid tag name: ${tagName}`);
+                                if (currentNode && textData) {
+                                    if ('!xml' !== currentNode.tagname) textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher, false);
                                 }
-                                const childNode = new XmlNode(tagName);
-                                if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
-                                childNode.add(this.options.textNodeName, tagContent);
-                                this.matcher.pop();
-                                this.isCurrentNodeStopNode = false;
-                                this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
-                            } else {
-                                if (isSelfClosing) {
-                                    ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
-                                    const childNode = new XmlNode(tagName);
-                                    if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
-                                    this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
+                                const lastTag = currentNode;
+                                if (lastTag && options.unpairedTagsSet.has(lastTag.tagname)) {
+                                    currentNode = this.tagsNodeStack.pop();
                                     this.matcher.pop();
-                                    this.isCurrentNodeStopNode = false;
-                                } else if (-1 !== this.options.unpairedTags.indexOf(tagName)) {
+                                }
+                                let isSelfClosing = false;
+                                if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
+                                    isSelfClosing = true;
+                                    if ("/" === tagName[tagName.length - 1]) {
+                                        tagName = tagName.substr(0, tagName.length - 1);
+                                        tagExp = tagName;
+                                    } else tagExp = tagExp.substr(0, tagExp.length - 1);
+                                    attrExpPresent = tagName !== tagExp;
+                                }
+                                let prefixedAttrs = null;
+                                let namespace;
+                                namespace = extractNamespace(rawTagName);
+                                if (tagName !== xmlObj.tagname) this.matcher.push(tagName, {}, namespace);
+                                if (tagName !== tagExp && attrExpPresent) {
+                                    prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
+                                    if (prefixedAttrs) extractRawAttributes(prefixedAttrs, options);
+                                }
+                                if (tagName !== xmlObj.tagname) this.isCurrentNodeStopNode = this.isItStopNode();
+                                const startIndex = i;
+                                if (this.isCurrentNodeStopNode) {
+                                    let tagContent = "";
+                                    if (isSelfClosing) i = result.closeIndex;
+                                    else if (options.unpairedTagsSet.has(tagName)) i = result.closeIndex;
+                                    else {
+                                        const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
+                                        if (!result) throw new Error(`Unexpected end of ${rawTagName}`);
+                                        i = result.i;
+                                        tagContent = result.tagContent;
+                                    }
                                     const childNode = new XmlNode(tagName);
                                     if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
-                                    this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
+                                    childNode.add(options.textNodeName, tagContent);
                                     this.matcher.pop();
                                     this.isCurrentNodeStopNode = false;
-                                    i = result.closeIndex;
-                                    continue;
-                                } else {
-                                    const childNode = new XmlNode(tagName);
-                                    if (this.tagsNodeStack.length > this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
-                                    this.tagsNodeStack.push(currentNode);
-                                    if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
                                     this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
-                                    currentNode = childNode;
+                                } else {
+                                    if (isSelfClosing) {
+                                        ({ tagName, tagExp } = transformTagName(options.transformTagName, tagName, tagExp, options));
+                                        const childNode = new XmlNode(tagName);
+                                        if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
+                                        this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
+                                        this.matcher.pop();
+                                        this.isCurrentNodeStopNode = false;
+                                    } else if (options.unpairedTagsSet.has(tagName)) {
+                                        const childNode = new XmlNode(tagName);
+                                        if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
+                                        this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
+                                        this.matcher.pop();
+                                        this.isCurrentNodeStopNode = false;
+                                        i = result.closeIndex;
+                                        continue;
+                                    } else {
+                                        const childNode = new XmlNode(tagName);
+                                        if (this.tagsNodeStack.length > options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
+                                        this.tagsNodeStack.push(currentNode);
+                                        if (prefixedAttrs) childNode[":@"] = prefixedAttrs;
+                                        this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
+                                        currentNode = childNode;
+                                    }
+                                    textData = "";
+                                    i = closeIndex;
                                 }
-                                textData = "";
-                                i = closeIndex;
                             }
-                        }
-                        else textData += xmlData[i];
+                        } else textData += xmlData[i];
                     }
                     return xmlObj.child;
                 };
@@ -15134,7 +15244,7 @@
                         const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
                         if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) return val;
                     }
-                    for (const entityName of Object.keys(this.docTypeEntities)){
+                    for (const entityName of this.docTypeEntitiesKeys){
                         const entity = this.docTypeEntities[entityName];
                         const matches = val.match(entity.regx);
                         if (matches) {
@@ -15148,7 +15258,8 @@
                             }
                         }
                     }
-                    for (const entityName of Object.keys(this.lastEntities)){
+                    if (-1 === val.indexOf('&')) return val;
+                    for (const entityName of this.lastEntitiesKeys){
                         const entity = this.lastEntities[entityName];
                         const matches = val.match(entity.regex);
                         if (matches) {
@@ -15158,7 +15269,7 @@
                         val = val.replace(entity.regex, entity.val);
                     }
                     if (-1 === val.indexOf('&')) return val;
-                    if (this.options.htmlEntities) for (const entityName of Object.keys(this.htmlEntities)){
+                    for (const entityName of this.htmlEntitiesKeys){
                         const entity = this.htmlEntities[entityName];
                         const matches = val.match(entity.regex);
                         if (matches) {
@@ -15179,30 +15290,35 @@
                     }
                     return textData;
                 }
-                function isItStopNode(stopNodeExpressions, matcher) {
-                    if (!stopNodeExpressions || 0 === stopNodeExpressions.length) return false;
-                    for(let i = 0; i < stopNodeExpressions.length; i++)if (matcher.matches(stopNodeExpressions[i])) return true;
-                    return false;
+                function isItStopNode() {
+                    if (0 === this.stopNodeExpressionsSet.size) return false;
+                    return this.matcher.matchesAny(this.stopNodeExpressionsSet);
                 }
                 function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
-                    let attrBoundary;
-                    let tagExp = "";
-                    for(let index = i; index < xmlData.length; index++){
-                        let ch = xmlData[index];
+                    let attrBoundary = 0;
+                    const chars = [];
+                    const len = xmlData.length;
+                    const closeCode0 = closingChar.charCodeAt(0);
+                    const closeCode1 = closingChar.length > 1 ? closingChar.charCodeAt(1) : -1;
+                    for(let index = i; index < len; index++){
+                        const code = xmlData.charCodeAt(index);
                         if (attrBoundary) {
-                            if (ch === attrBoundary) attrBoundary = "";
-                        } else if ('"' === ch || "'" === ch) attrBoundary = ch;
-                        else if (ch === closingChar[0]) {
-                            if (!closingChar[1]) return {
-                                data: tagExp,
-                                index: index
+                            if (code === attrBoundary) attrBoundary = 0;
+                        } else if (34 === code || 39 === code) attrBoundary = code;
+                        else if (code === closeCode0) {
+                            if (-1 === closeCode1) return {
+                                data: String.fromCharCode(...chars),
+                                index
                             };
-                            else if (xmlData[index + 1] === closingChar[1]) return {
-                                data: tagExp,
-                                index: index
+                            else if (xmlData.charCodeAt(index + 1) === closeCode1) return {
+                                data: String.fromCharCode(...chars),
+                                index
                             };
-                        } else if ('\t' === ch) ch = " ";
-                        tagExp += ch;
+                        } else if (9 === code) {
+                            chars.push(32);
+                            continue;
+                        }
+                        chars.push(code);
                     }
                 }
                 function findClosingIndex(xmlData, str, i, errMsg) {
@@ -15210,6 +15326,11 @@
                     if (-1 !== closingIndex) return closingIndex + str.length - 1;
                     throw new Error(errMsg);
                 }
+                function findClosingChar(xmlData, char, i, errMsg) {
+                    const closingIndex = xmlData.indexOf(char, i);
+                    if (-1 === closingIndex) throw new Error(errMsg);
+                    return closingIndex;
+                }
                 function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
                     const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
                     if (!result) return;
@@ -15241,32 +15362,36 @@
                 function readStopNodeData(xmlData, tagName, i) {
                     const startIndex = i;
                     let openTagCount = 1;
-                    for(; i < xmlData.length; i++)if ("<" === xmlData[i]) if ("/" === xmlData[i + 1]) {
-                        const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
-                        let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
-                        if (closeTagName === tagName) {
-                            openTagCount--;
-                            if (0 === openTagCount) return {
-                                tagContent: xmlData.substring(startIndex, i),
-                                i: closeIndex
-                            };
-                        }
-                        i = closeIndex;
-                    } else if ('?' === xmlData[i + 1]) {
-                        const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
-                        i = closeIndex;
-                    } else if ('!--' === xmlData.substr(i + 1, 3)) {
-                        const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
-                        i = closeIndex;
-                    } else if ('![' === xmlData.substr(i + 1, 2)) {
-                        const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
-                        i = closeIndex;
-                    } else {
-                        const tagData = readTagExp(xmlData, i, '>');
-                        if (tagData) {
-                            const openTagName = tagData && tagData.tagName;
-                            if (openTagName === tagName && "/" !== tagData.tagExp[tagData.tagExp.length - 1]) openTagCount++;
-                            i = tagData.closeIndex;
+                    const xmllen = xmlData.length;
+                    for(; i < xmllen; i++)if ("<" === xmlData[i]) {
+                        const c1 = xmlData.charCodeAt(i + 1);
+                        if (47 === c1) {
+                            const closeIndex = findClosingChar(xmlData, ">", i, `${tagName} is not closed`);
+                            let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
+                            if (closeTagName === tagName) {
+                                openTagCount--;
+                                if (0 === openTagCount) return {
+                                    tagContent: xmlData.substring(startIndex, i),
+                                    i: closeIndex
+                                };
+                            }
+                            i = closeIndex;
+                        } else if (63 === c1) {
+                            const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
+                            i = closeIndex;
+                        } else if (33 === c1 && 45 === xmlData.charCodeAt(i + 2) && 45 === xmlData.charCodeAt(i + 3)) {
+                            const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
+                            i = closeIndex;
+                        } else if (33 === c1 && 91 === xmlData.charCodeAt(i + 2)) {
+                            const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
+                            i = closeIndex;
+                        } else {
+                            const tagData = readTagExp(xmlData, i, '>');
+                            if (tagData) {
+                                const openTagName = tagData && tagData.tagName;
+                                if (openTagName === tagName && "/" !== tagData.tagExp[tagData.tagExp.length - 1]) openTagCount++;
+                                i = tagData.closeIndex;
+                            }
                         }
                     }
                 }
@@ -21084,7 +21209,7 @@
                 function timestamp_timestampMs(timestamp) {
                     return 1000 * Number(timestamp.seconds) + Math.round(timestamp.nanos / 1000000);
                 }
-                var package_namespaceObject = JSON.parse('{"UU":"@dan-uni/dan-any","rE":"1.3.9","TB":"https://github.com/ani-uni/danuni/tree/master/packages/dan-any#readme"}');
+                var package_namespaceObject = JSON.parse('{"UU":"@dan-uni/dan-any","rE":"1.4.1","TB":"https://github.com/ani-uni/danuni/tree/master/packages/dan-any#readme"}');
                 const color_pad = (s)=>s.length < 2 ? `0${s}` : s;
                 const decimalToHex = (n)=>color_pad(n.toString(16));
                 const isDarkColor = ({ r, g, b })=>0.299 * r + 0.587 * g + 0.114 * b < 0x30;
@@ -23810,7 +23935,7 @@
                             mode: 4,
                             senderID: senderID.toString(),
                             ctime: new Date(`${args.ctime} GMT+0800`),
-                            weight: 10,
+                            weight: 11,
                             pool: 2,
                             attr: [
                                 "Protect"
@@ -23818,6 +23943,9 @@
                             platform: platform.PlatformVideoSource.Bilibili,
                             extra: {
                                 bili: {
+                                    dmid: args.id,
+                                    attr: args.attr,
+                                    mid: args.mid,
                                     command: args
                                 }
                             }
@@ -25057,6 +25185,8 @@
                             const ok = this.dans.every((d)=>d.senderID.endsWith(`@${platform.PlatformVideoSource.Bilibili}`));
                             if (!ok) throw new Error('存在其他来源的senderID，请关闭该功能再试！');
                         }
+                        let ds = this.dans.map((dan)=>dan.toBiliXML(options));
+                        if (options?.skipBiliCommand) ds = ds.filter((d)=>null !== d);
                         const builder = new json2xml({
                             ignoreAttributes: false
                         });
@@ -25077,7 +25207,7 @@
                                     ...DanUniConvertTipTemplate,
                                     data: this.getShared('SOID')
                                 },
-                                d: this.dans.map((dan)=>dan.toBiliXML(options))
+                                d: ds
                             }
                         });
                     }
@@ -25241,7 +25371,7 @@
                 function main(that) {
                     that.dans.forEach((d)=>{
                         if (d.platform !== platform.PlatformVideoSource.Bilibili) throw new Error('bili-dedupe: 仅支持B站(主站)的弹幕');
-                        if (!d.extra.bili?.dmid) throw new Error('bili-dedupe: 弹幕缺少bili extra dmid字段');
+                        if (!d.extra.bili?.dmid && !d.extra.bili?.command?.id) throw new Error('bili-dedupe: 弹幕缺少bili extra dmid字段');
                     });
                     const map = new Map();
                     that.dans.forEach((d)=>map.set(d.extra.bili.dmid, d));