@ckeditor/ckeditor5-engine 44.2.1 → 44.3.0-alpha.0

package/src/view/element.js

@@ -8,9 +8,10 @@
 import Node from './node.js';
 import Text from './text.js';
 import TextProxy from './textproxy.js';
-import { isIterable, toArray, toMap } from '@ckeditor/ckeditor5-utils';
-import { default as Matcher } from './matcher.js';
+import { isIterable, toMap } from '@ckeditor/ckeditor5-utils';
+import { default as Matcher, isPatternMatched } from './matcher.js';
 import { default as StylesMap } from './stylesmap.js';
+import TokenList from './tokenlist.js';
 // @if CK_DEBUG_ENGINE // const { convertMapToTags } = require( '../dev-utils/utils' );
 /**
  * View element.
@@ -36,6 +37,22 @@ import { default as StylesMap } from './stylesmap.js';
  * should be used to create generic view elements.
  */
 export default class Element extends Node {
+    /**
+     * Set of classes associated with element instance.
+     *
+     * Note that this is just an alias for `this._attrs.get( 'class' );`
+     */
+    get _classes() {
+        return this._attrs.get('class');
+    }
+    /**
+     * Normalized styles.
+     *
+     * Note that this is just an alias for `this._attrs.get( 'style' );`
+     */
+    get _styles() {
+        return this._attrs.get('style');
+    }
     /**
      * Creates a view element.
      *
@@ -73,24 +90,11 @@ export default class Element extends Node {
          */
         this._customProperties = new Map();
         this.name = name;
-        this._attrs = parseAttributes(attrs);
+        this._attrs = this._parseAttributes(attrs);
         this._children = [];
         if (children) {
             this._insertChild(0, children);
         }
-        this._classes = new Set();
-        if (this._attrs.has('class')) {
-            // Remove class attribute and handle it by class set.
-            const classString = this._attrs.get('class');
-            parseClasses(this._classes, classString);
-            this._attrs.delete('class');
-        }
-        this._styles = new StylesMap(this.document.stylesProcessor);
-        if (this._attrs.has('style')) {
-            // Remove style attribute and handle it by styles map.
-            this._styles.setTo(this._attrs.get('style'));
-            this._attrs.delete('style');
-        }
     }
     /**
      * Number of element's children.
@@ -136,13 +140,19 @@ export default class Element extends Node {
      * @returns Keys for attributes.
      */
     *getAttributeKeys() {
-        if (this._classes.size > 0) {
+        // This is yielded in this specific order to maintain backward compatibility of data.
+        // Otherwise, we could simply just have the `for` loop only inside this method.
+        if (this._classes) {
             yield 'class';
         }
-        if (!this._styles.isEmpty) {
+        if (this._styles) {
             yield 'style';
         }
-        yield* this._attrs.keys();
+        for (const key of this._attrs.keys()) {
+            if (key != 'class' && key != 'style') {
+                yield key;
+            }
+        }
     }
     /**
      * Returns iterator that iterates over this element's attributes.
@@ -151,12 +161,8 @@ export default class Element extends Node {
      * This format is accepted by native `Map` object and also can be passed in `Node` constructor.
      */
     *getAttributes() {
-        yield* this._attrs.entries();
-        if (this._classes.size > 0) {
-            yield ['class', this.getAttribute('class')];
-        }
-        if (!this._styles.isEmpty) {
-            yield ['style', this.getAttribute('style')];
+        for (const [name, value] of this._attrs.entries()) {
+            yield [name, String(value)];
         }
     }
     /**
@@ -166,17 +172,7 @@ export default class Element extends Node {
      * @returns Attribute value.
      */
     getAttribute(key) {
-        if (key == 'class') {
-            if (this._classes.size > 0) {
-                return [...this._classes].join(' ');
-            }
-            return undefined;
-        }
-        if (key == 'style') {
-            const inlineStyle = this._styles.toString();
-            return inlineStyle == '' ? undefined : inlineStyle;
-        }
-        return this._attrs.get(key);
+        return this._attrs.has(key) ? String(this._attrs.get(key)) : undefined;
     }
     /**
      * Returns a boolean indicating whether an attribute with the specified key exists in the element.
@@ -184,14 +180,19 @@ export default class Element extends Node {
      * @param key Attribute key.
      * @returns `true` if attribute with the specified key exists in the element, `false` otherwise.
      */
-    hasAttribute(key) {
-        if (key == 'class') {
-            return this._classes.size > 0;
+    hasAttribute(key, token) {
+        if (!this._attrs.has(key)) {
+            return false;
         }
-        if (key == 'style') {
-            return !this._styles.isEmpty;
+        if (token !== undefined) {
+            if (usesStylesMap(this.name, key) || usesTokenList(this.name, key)) {
+                return this._attrs.get(key).has(token);
+            }
+            else {
+                return this._attrs.get(key) === token;
+            }
         }
-        return this._attrs.has(key);
+        return true;
     }
     /**
      * Checks if this element is similar to other element.
@@ -211,26 +212,21 @@ export default class Element extends Node {
             return false;
         }
         // Check number of attributes, classes and styles.
-        if (this._attrs.size !== otherElement._attrs.size || this._classes.size !== otherElement._classes.size ||
-            this._styles.size !== otherElement._styles.size) {
+        if (this._attrs.size !== otherElement._attrs.size) {
             return false;
         }
         // Check if attributes are the same.
         for (const [key, value] of this._attrs) {
-            if (!otherElement._attrs.has(key) || otherElement._attrs.get(key) !== value) {
+            const otherValue = otherElement._attrs.get(key);
+            if (otherValue === undefined) {
                 return false;
             }
-        }
-        // Check if classes are the same.
-        for (const className of this._classes) {
-            if (!otherElement._classes.has(className)) {
-                return false;
+            if (typeof value == 'string' || typeof otherValue == 'string') {
+                if (otherValue !== value) {
+                    return false;
+                }
             }
-        }
-        // Check if styles are the same.
-        for (const property of this._styles.getStyleNames()) {
-            if (!otherElement._styles.has(property) ||
-                otherElement._styles.getAsString(property) !== this._styles.getAsString(property)) {
+            else if (!value.isSimilar(otherValue)) {
                 return false;
             }
         }
@@ -247,7 +243,7 @@ export default class Element extends Node {
      */
     hasClass(...className) {
         for (const name of className) {
-            if (!this._classes.has(name)) {
+            if (!this._classes || !this._classes.has(name)) {
                 return false;
             }
         }
@@ -257,10 +253,15 @@ export default class Element extends Node {
      * Returns iterator that contains all class names.
      */
     getClassNames() {
-        return this._classes.keys();
+        const array = this._classes ? this._classes.keys() : [];
+        // This is overcomplicated because we need to be backward compatible for use cases when iterator is expected.
+        const iterator = array[Symbol.iterator]();
+        return Object.assign(array, {
+            next: iterator.next.bind(iterator)
+        });
     }
     /**
-     * Returns style value for the given property mae.
+     * Returns style value for the given property name.
      * If the style does not exist `undefined` is returned.
      *
      * **Note**: This method can work with normalized style names if
@@ -285,7 +286,7 @@ export default class Element extends Node {
      * ```
      */
     getStyle(property) {
-        return this._styles.getAsString(property);
+        return this._styles && this._styles.getAsString(property);
     }
     /**
      * Returns a normalized style object or single style value.
@@ -322,15 +323,15 @@ export default class Element extends Node {
      * @param property Name of CSS property
      */
     getNormalizedStyle(property) {
-        return this._styles.getNormalized(property);
+        return this._styles && this._styles.getNormalized(property);
     }
     /**
-     * Returns iterator that contains all style names.
+     * Returns an array that contains all style names.
      *
      * @param expand Expand shorthand style properties and return all equivalent style representations.
      */
     getStyleNames(expand) {
-        return this._styles.getStyleNames(expand);
+        return this._styles ? this._styles.getStyleNames(expand) : [];
     }
     /**
      * Returns true if style keys are present.
@@ -343,7 +344,7 @@ export default class Element extends Node {
      */
     hasStyle(...property) {
         for (const name of property) {
-            if (!this._styles.has(name)) {
+            if (!this._styles || !this._styles.has(name)) {
                 return false;
             }
         }
@@ -407,9 +408,12 @@ export default class Element extends Node {
      * **Note**: Classes, styles and other attributes are sorted alphabetically.
      */
     getIdentity() {
-        const classes = Array.from(this._classes).sort().join(',');
-        const styles = this._styles.toString();
-        const attributes = Array.from(this._attrs).map(i => `${i[0]}="${i[1]}"`).sort().join(' ');
+        const classes = this._classes ? this._classes.keys().sort().join(',') : '';
+        const styles = this._styles && String(this._styles);
+        const attributes = Array.from(this._attrs)
+            .filter(([key]) => key != 'style' && key != 'class')
+            .map(i => `${i[0]}="${i[1]}"`)
+            .sort().join(' ');
         return this.name +
             (classes == '' ? '' : ` class="${classes}"`) +
             (!styles ? '' : ` style="${styles}"`) +
@@ -443,10 +447,6 @@ export default class Element extends Node {
         }
         // ContainerElement and AttributeElement should be also cloned properly.
         const cloned = new this.constructor(this.document, this.name, this._attrs, childrenClone);
-        // Classes and styles are cloned separately - this solution is faster than adding them back to attributes and
-        // parse once again in constructor.
-        cloned._classes = new Set(this._classes);
-        cloned._styles.set(this._styles.getNormalized());
         // Clone custom properties.
         cloned._customProperties = new Map(this._customProperties);
         // Clone filler offset method.
@@ -522,19 +522,37 @@ export default class Element extends Node {
      * @internal
      * @param key Attribute key.
      * @param value Attribute value.
+     * @param overwrite Whether tokenized attribute should override the attribute value or just add a token.
      * @fires change
      */
-    _setAttribute(key, value) {
-        const stringValue = String(value);
+    _setAttribute(key, value, overwrite = true) {
         this._fireChange('attributes', this);
-        if (key == 'class') {
-            parseClasses(this._classes, stringValue);
-        }
-        else if (key == 'style') {
-            this._styles.setTo(stringValue);
+        if (usesStylesMap(this.name, key) || usesTokenList(this.name, key)) {
+            let currentValue = this._attrs.get(key);
+            if (!currentValue) {
+                currentValue = usesStylesMap(this.name, key) ?
+                    new StylesMap(this.document.stylesProcessor) :
+                    new TokenList();
+                this._attrs.set(key, currentValue);
+            }
+            if (overwrite) {
+                // If reset is set then value have to be a string to tokenize.
+                currentValue.setTo(String(value));
+            }
+            else if (usesStylesMap(this.name, key)) {
+                if (Array.isArray(value)) {
+                    currentValue.set(value[0], value[1]);
+                }
+                else {
+                    currentValue.set(value);
+                }
+            }
+            else { // TokenList.
+                currentValue.set(typeof value == 'string' ? value.split(/\s+/) : value);
+            }
         }
         else {
-            this._attrs.set(key, stringValue);
+            this._attrs.set(key, String(value));
         }
     }
     /**
@@ -543,28 +561,26 @@ export default class Element extends Node {
      * @see module:engine/view/downcastwriter~DowncastWriter#removeAttribute
      * @internal
      * @param key Attribute key.
+     * @param tokens Attribute value tokens to remove. The whole attribute is removed if not specified.
      * @returns Returns true if an attribute existed and has been removed.
      * @fires change
      */
-    _removeAttribute(key) {
+    _removeAttribute(key, tokens) {
         this._fireChange('attributes', this);
-        // Remove class attribute.
-        if (key == 'class') {
-            if (this._classes.size > 0) {
-                this._classes.clear();
-                return true;
+        if (tokens !== undefined && (usesStylesMap(this.name, key) || usesTokenList(this.name, key))) {
+            const currentValue = this._attrs.get(key);
+            if (!currentValue) {
+                return false;
             }
-            return false;
-        }
-        // Remove style attribute.
-        if (key == 'style') {
-            if (!this._styles.isEmpty) {
-                this._styles.clear();
-                return true;
+            if (usesTokenList(this.name, key) && typeof tokens == 'string') {
+                tokens = tokens.split(/\s+/);
+            }
+            currentValue.remove(tokens);
+            if (currentValue.isEmpty) {
+                return this._attrs.delete(key);
             }
             return false;
         }
-        // Remove other attributes.
         return this._attrs.delete(key);
     }
     /**
@@ -580,10 +596,7 @@ export default class Element extends Node {
      * @fires change
      */
     _addClass(className) {
-        this._fireChange('attributes', this);
-        for (const name of toArray(className)) {
-            this._classes.add(name);
-        }
+        this._setAttribute('class', className, false);
     }
     /**
      * Removes specified class.
@@ -598,18 +611,14 @@ export default class Element extends Node {
      * @fires change
      */
     _removeClass(className) {
-        this._fireChange('attributes', this);
-        for (const name of toArray(className)) {
-            this._classes.delete(name);
-        }
+        this._removeAttribute('class', className);
     }
     _setStyle(property, value) {
-        this._fireChange('attributes', this);
         if (typeof property != 'string') {
-            this._styles.set(property);
+            this._setAttribute('style', property, false);
         }
         else {
-            this._styles.set(property, value);
+            this._setAttribute('style', [property, value], false);
         }
     }
     /**
@@ -629,9 +638,281 @@ export default class Element extends Node {
      * @fires change
      */
     _removeStyle(property) {
+        this._removeAttribute('style', property);
+    }
+    /**
+     * Used by the {@link module:engine/view/matcher~Matcher Matcher} to collect matching attribute tuples
+     * (attribute name and optional token).
+     *
+     * Normalized patterns can be used in following ways:
+     * - to match any attribute name with any or no value:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ true, true ]
+     * ]
+     * ```
+     *
+     * - to match a specific attribute with any value:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ 'required', true ]
+     * ]
+     * ```
+     *
+     * - to match an attribute name with a RegExp with any value:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ /h[1-6]/, true ]
+     * ]
+     * ```
+     *
+     * 	- to match a specific attribute with the exact value:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ 'rel', 'nofollow' ]
+     * ]
+     * ```
+     *
+     * 	- to match a specific attribute with a value matching a RegExp:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ 'src', /^https/ ]
+     * ]
+     * ```
+     *
+     * 	- to match an attribute name with a RegExp and the exact value:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ /^data-property-/, 'foobar' ],
+     * ]
+     * ```
+     *
+     * 	- to match an attribute name with a RegExp and match a value with another RegExp:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ /^data-property-/, /^foo/ ]
+     * ]
+     * ```
+     *
+     * 	- to match a specific style property with the value matching a RegExp:
+     *
+     * ```ts
+     * patterns: [
+     * 	[ 'style', 'font-size', /px$/ ]
+     * ]
+     * ```
+     *
+     * 	- to match a specific class (class attribute is tokenized so it matches tokens individually):
+     *
+     * ```ts
+     * patterns: [
+     * 	[ 'class', 'foo' ]
+     * ]
+     * ```
+     *
+     * @internal
+     * @param patterns An array of normalized patterns (tuples of 2 or 3 items depending on if tokenized attribute value match is needed).
+     * @param match An array to populate with matching tuples.
+     * @param exclude Array of attribute names to exclude from match.
+     * @returns `true` if element matches all patterns. The matching tuples are pushed to the `match` array.
+     */
+    _collectAttributesMatch(patterns, match, exclude) {
+        for (const [keyPattern, tokenPattern, valuePattern] of patterns) {
+            let hasKey = false;
+            let hasValue = false;
+            for (const [key, value] of this._attrs) {
+                if (exclude && exclude.includes(key) || !isPatternMatched(keyPattern, key)) {
+                    continue;
+                }
+                hasKey = true;
+                if (typeof value == 'string') {
+                    if (isPatternMatched(tokenPattern, value)) {
+                        match.push([key]);
+                        hasValue = true;
+                    }
+                    else if (!(keyPattern instanceof RegExp)) {
+                        return false;
+                    }
+                }
+                else {
+                    const tokenMatch = value._getTokensMatch(tokenPattern, valuePattern || true);
+                    if (tokenMatch) {
+                        hasValue = true;
+                        for (const tokenMatchItem of tokenMatch) {
+                            match.push([key, tokenMatchItem]);
+                        }
+                    }
+                    else if (!(keyPattern instanceof RegExp)) {
+                        return false;
+                    }
+                }
+            }
+            if (!hasKey || !hasValue) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Used by the {@link module:engine/conversion/viewconsumable~ViewConsumable} to collect the
+     * {@link module:engine/view/element~NormalizedConsumables} for the element.
+     *
+     * When `key` and `token` parameters are provided the output is filtered for the specified attribute and it's tokens and related tokens.
+     *
+     * @internal
+     * @param key Attribute name.
+     * @param token Reference token to collect all related tokens.
+     */
+    _getConsumables(key, token) {
+        const attributes = [];
+        if (key) {
+            const value = this._attrs.get(key);
+            if (value !== undefined) {
+                if (typeof value == 'string') {
+                    attributes.push([key]);
+                }
+                else {
+                    for (const prop of value._getConsumables(token)) {
+                        attributes.push([key, prop]);
+                    }
+                }
+            }
+        }
+        else {
+            for (const [key, value] of this._attrs) {
+                if (typeof value == 'string') {
+                    attributes.push([key]);
+                }
+                else {
+                    for (const prop of value._getConsumables()) {
+                        attributes.push([key, prop]);
+                    }
+                }
+            }
+        }
+        return {
+            name: !key,
+            attributes
+        };
+    }
+    /**
+     * Verify if the given element can be merged without conflicts into the element.
+     *
+     * Note that this method is extended by the {@link module:engine/view/attributeelement~AttributeElement} implementation.
+     *
+     * This method is used by the {@link module:engine/view/downcastwriter~DowncastWriter} while down-casting
+     * an {@link module:engine/view/attributeelement~AttributeElement} to merge it with other AttributeElement.
+     *
+     * @internal
+     * @returns Returns `true` if elements can be merged.
+     */
+    _canMergeAttributesFrom(otherElement) {
+        if (this.name != otherElement.name) {
+            return false;
+        }
+        for (const [key, otherValue] of otherElement._attrs) {
+            const value = this._attrs.get(key);
+            if (value === undefined) {
+                continue;
+            }
+            if (typeof value == 'string' || typeof otherValue == 'string') {
+                if (value !== otherValue) {
+                    return false;
+                }
+            }
+            else if (!value._canMergeFrom(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Merges attributes of a given element into the element.
+     * This includes also tokenized attributes like style and class.
+     *
+     * Note that you should make sure there are no conflicts before merging (see {@link #_canMergeAttributesFrom}).
+     *
+     * This method is used by the {@link module:engine/view/downcastwriter~DowncastWriter} while down-casting
+     * an {@link module:engine/view/attributeelement~AttributeElement} to merge it with other AttributeElement.
+     *
+     * @internal
+     */
+    _mergeAttributesFrom(otherElement) {
         this._fireChange('attributes', this);
-        for (const name of toArray(property)) {
-            this._styles.remove(name);
+        // Move all attributes/classes/styles from wrapper to wrapped AttributeElement.
+        for (const [key, otherValue] of otherElement._attrs) {
+            const value = this._attrs.get(key);
+            if (value === undefined || typeof value == 'string' || typeof otherValue == 'string') {
+                this._setAttribute(key, otherValue);
+            }
+            else {
+                value._mergeFrom(otherValue);
+            }
+        }
+    }
+    /**
+     * Verify if the given element attributes can be fully subtracted from the element.
+     *
+     * Note that this method is extended by the {@link module:engine/view/attributeelement~AttributeElement} implementation.
+     *
+     * This method is used by the {@link module:engine/view/downcastwriter~DowncastWriter} while down-casting
+     * an {@link module:engine/view/attributeelement~AttributeElement} to unwrap the AttributeElement.
+     *
+     * @internal
+     * @returns Returns `true` if elements attributes can be fully subtracted.
+     */
+    _canSubtractAttributesOf(otherElement) {
+        if (this.name != otherElement.name) {
+            return false;
+        }
+        for (const [key, otherValue] of otherElement._attrs) {
+            const value = this._attrs.get(key);
+            if (value === undefined) {
+                return false;
+            }
+            if (typeof value == 'string' || typeof otherValue == 'string') {
+                if (value !== otherValue) {
+                    return false;
+                }
+            }
+            else if (!value._isMatching(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Removes (subtracts) corresponding attributes of the given element from the element.
+     * This includes also tokenized attributes like style and class.
+     * All attributes, classes and styles from given element should be present inside the element being unwrapped.
+     *
+     * Note that you should make sure all attributes could be subtracted before subtracting them (see {@link #_canSubtractAttributesOf}).
+     *
+     * This method is used by the {@link module:engine/view/downcastwriter~DowncastWriter} while down-casting
+     * an {@link module:engine/view/attributeelement~AttributeElement} to unwrap the AttributeElement.
+     *
+     * @internal
+     */
+    _subtractAttributesOf(otherElement) {
+        this._fireChange('attributes', this);
+        for (const [key, otherValue] of otherElement._attrs) {
+            const value = this._attrs.get(key);
+            if (typeof value == 'string' || typeof otherValue == 'string') {
+                this._attrs.delete(key);
+            }
+            else {
+                value.remove(otherValue.keys());
+                if (value.isEmpty) {
+                    this._attrs.delete(key);
+                }
+            }
         }
     }
     /**
@@ -654,6 +935,40 @@ export default class Element extends Node {
     _removeCustomProperty(key) {
         return this._customProperties.delete(key);
     }
+    /**
+     * Parses attributes provided to the element constructor before they are applied to an element. If attributes are passed
+     * as an object (instead of `Iterable`), the object is transformed to the map. Attributes with `null` value are removed.
+     * Attributes with non-`String` value are converted to `String`.
+     *
+     * @param attrs Attributes to parse.
+     * @returns Parsed attributes.
+     */
+    _parseAttributes(attrs) {
+        const attrsMap = toMap(attrs);
+        for (const [key, value] of attrsMap) {
+            if (value === null) {
+                attrsMap.delete(key);
+            }
+            else if (usesStylesMap(this.name, key)) {
+                // This is either an element clone so we need to clone styles map, or a new instance which requires value to be parsed.
+                const newValue = value instanceof StylesMap ?
+                    value._clone() :
+                    new StylesMap(this.document.stylesProcessor).setTo(String(value));
+                attrsMap.set(key, newValue);
+            }
+            else if (usesTokenList(this.name, key)) {
+                // This is either an element clone so we need to clone token list, or a new instance which requires value to be parsed.
+                const newValue = value instanceof TokenList ?
+                    value._clone() :
+                    new TokenList().setTo(String(value));
+                attrsMap.set(key, newValue);
+            }
+            else if (typeof value != 'string') {
+                attrsMap.set(key, String(value));
+            }
+        }
+        return attrsMap;
+    }
 }
 // The magic of type inference using `is` method is centralized in `TypeCheckable` class.
 // Proper overload would interfere with that.
@@ -667,38 +982,6 @@ Element.prototype.is = function (type, name) {
         return name === this.name && (type === 'element' || type === 'view:element');
     }
 };
-/**
- * Parses attributes provided to the element constructor before they are applied to an element. If attributes are passed
- * as an object (instead of `Iterable`), the object is transformed to the map. Attributes with `null` value are removed.
- * Attributes with non-`String` value are converted to `String`.
- *
- * @param attrs Attributes to parse.
- * @returns Parsed attributes.
- */
-function parseAttributes(attrs) {
-    const attrsMap = toMap(attrs);
-    for (const [key, value] of attrsMap) {
-        if (value === null) {
-            attrsMap.delete(key);
-        }
-        else if (typeof value != 'string') {
-            attrsMap.set(key, String(value));
-        }
-    }
-    return attrsMap;
-}
-/**
- * Parses class attribute and puts all classes into classes set.
- * Classes set s cleared before insertion.
- *
- * @param classesSet Set to insert parsed classes.
- * @param classesString String with classes to parse.
- */
-function parseClasses(classesSet, classesString) {
-    const classArray = classesString.split(/\s+/);
-    classesSet.clear();
-    classArray.forEach(name => classesSet.add(name));
-}
 /**
  * Converts strings to Text and non-iterables to arrays.
  */
@@ -724,3 +1007,15 @@ function normalize(document, nodes) {
     }
     return normalizedNodes;
 }
+/**
+ * Returns `true` if an attribute on a given element should be handled as a TokenList.
+ */
+function usesTokenList(elementName, key) {
+    return key == 'class' || elementName == 'a' && key == 'rel';
+}
+/**
+ * Returns `true` if an attribute on a given element should be handled as a StylesMap.
+ */
+function usesStylesMap(elementName, key) {
+    return key == 'style';
+}