How to use the html-tags.indexOf function in html-tags

return;
      }

      // Else try to import it as a node module.
      try {
        // npm modules are required via relative paths to support working with a locally linked idyll.
        resolved = slash(resolve.sync(name, { basedir: this.paths.INPUT_DIR }));
      } catch (err) {
        // Import errors are silently discarded.
        return;
      }
    });

    if (!resolved) {
      if (
        htmlTags.indexOf(name) > -1 ||
        svgTags.indexOf(name) > -1 ||
        name === 'root'
      ) {
        // It is a valid HTML component, but should not be added to the map.
        return;
      } else {
        if (['fullwidth', 'textcontainer'].indexOf(name) > -1) {
          throw new errors.OutOfDateError(name);
        }
        throw new errors.InvalidComponentError(name);
      }
    }

    debug(`Resolved component ${name} to ${resolved}`);
    return resolved;
  }

componentClass = componentClass[split[i]];
      }
      if (componentClass.hasOwnProperty('default')) {
        componentClass = componentClass.default;
      }
      if (isClass(componentClass)) {
        const update = component.handleUpdateProps(id);
        try {
          return class extends componentClass {
            updateProps(newProps) {
              return update.call(this, newProps);
            }
          }
        } catch(e) { /* just in case something weird happens, return the unmodified class */ }
      }
    } else if (htmlTags.indexOf(name.toLowerCase()) > -1) {
      componentClass = name.toLowerCase();
    }

    return componentClass;
  });

if (componentClass.default) {
          return class extends componentClass.default {
            updateProps(newProps) {
              return update.call(this, newProps);
            }
          }
        }

        return class extends componentClass {
          updateProps(newProps) {
            return update.call(this, newProps);
          }
        }
      }
    } else if (htmlTags.indexOf(name.toLowerCase()) > -1) {
      componentClass = name.toLowerCase();
    }

    return componentClass;
  });

_classCallCheck(this, _class2);

            return _possibleConstructorReturn(this, (_class2.__proto__ || Object.getPrototypeOf(_class2)).apply(this, arguments));
          }

          _createClass(_class2, [{
            key: 'updateProps',
            value: function updateProps(newProps) {
              return update.call(this, newProps);
            }
          }]);

          return _class2;
        }(componentClass);
      }
    } else if (htmlTags.indexOf(name.toLowerCase()) > -1) {
      componentClass = name.toLowerCase();
    }

    return componentClass;
  });

return;
					}

					if (optionsMatches(options, 'ignoreNamespaces', tagNode.namespace)) {
						return;
					}

					if (optionsMatches(options, 'ignoreTypes', tagNode.value)) {
						return;
					}

					const tagName = tagNode.value;
					const tagNameLowerCase = tagName.toLowerCase();

					if (
						htmlTags.indexOf(tagNameLowerCase) !== -1 ||
						svgTags.indexOf(tagNameLowerCase) !== -1 ||
						keywordSets.nonStandardHtmlTags.has(tagNameLowerCase) ||
						mathMLTags.indexOf(tagNameLowerCase) !== -1
					) {
						return;
					}

					report({
						message: messages.rejected(tagName),
						node: rule,
						index: tagNode.sourceIndex,
						ruleName,
						result,
					});
				});
			});

var isReservedTag = function isReservedTag(tag) {
  return ~htmlTags.indexOf(tag) || ~svgTags.indexOf(tag)
}

selectorTree.walkTags(tagNode => {
          if (!isStandardSyntaxTypeSelector(tagNode)) { return }

          if (optionsMatches(options, "ignoreTypes", tagNode.value)) { return }

          const tagName = tagNode.value
          const tagNameLowerCase = tagName.toLowerCase()

          if (htmlTags.indexOf(tagNameLowerCase) !== -1
            || svgTags.indexOf(tagNameLowerCase) !== -1
            || nonStandardHtmlTags.has(tagNameLowerCase)
          ) { return }

          report({
            message: messages.rejected(tagName),
            node: rule,
            index: tagNode.sourceIndex,
            ruleName,
            result,
          })
        })
      })

if (selector.indexOf('-') === -1) {
		return false;
	}

	const selectorLowerCase = selector.toLowerCase();

	if (selectorLowerCase !== selector) {
		return false;
	}

	if (svgTags.indexOf(selectorLowerCase) !== -1) {
		return false;
	}

	if (htmlTags.indexOf(selectorLowerCase) !== -1) {
		return false;
	}

	if (keywordSets.nonStandardHtmlTags.has(selectorLowerCase)) {
		return false;
	}

	if (mathMLTags.indexOf(selectorLowerCase) !== -1) {
		return false;
	}

	return true;
};

if (node.length) {
                        const reference2 = [];
                        loop(node, reference2);

                        push(node, [
                            name,
                            hspan(t.parenthesis, '('),
                            ...reference2,
                            hspan(t.parenthesis, ')'),
                        ]);
                    } else {
                        push(node, name);
                    }
                }
                if (type === t.tag) {
                    if (~htmlTags.indexOf(value)) {
                        push(node, [
                            node.ns,
                            hspan(t.tag, value),
                        ]);
                    } else {
                        push(node, [
                            node.ns,
                            value,
                        ]);
                    }
                }
                if (type === t.className) {
                    push(node, [
                        node.ns,
                        hspan(t.className, `.${value}`),
                    ]);