html-validate 6.6.1 → 6.8.0

package/dist/cjs/core.js

@@ -4,6 +4,8 @@ var fs = require('fs');
 var betterAjvErrors = require('@sidvind/better-ajv-errors');
 var Ajv = require('ajv');
 var deepmerge = require('deepmerge');
+var espree = require('espree');
+var walk = require('acorn-walk');
 var path = require('path');
 var semver = require('semver');
 var kleur = require('kleur');
@@ -12,10 +14,30 @@ var stylishImpl = require('@html-validate/stylish');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var betterAjvErrors__default = /*#__PURE__*/_interopDefaultLegacy(betterAjvErrors);
 var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
 var deepmerge__default = /*#__PURE__*/_interopDefaultLegacy(deepmerge);
+var espree__namespace = /*#__PURE__*/_interopNamespace(espree);
+var walk__namespace = /*#__PURE__*/_interopNamespace(walk);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var semver__default = /*#__PURE__*/_interopDefaultLegacy(semver);
 var kleur__default = /*#__PURE__*/_interopDefaultLegacy(kleur);
@@ -256,7 +278,7 @@ class NestedError extends Error {
     constructor(message, nested) {
         super(message);
         Error.captureStackTrace(this, NestedError);
-        if (nested) {
+        if (nested && nested.stack) {
             this.stack += `\nCaused by: ${nested.stack}`;
         }
     }
@@ -1211,6 +1233,27 @@ class Attribute {
     }
 }
 
+function getCSSDeclarations(value) {
+    return value
+        .trim()
+        .split(";")
+        .filter(Boolean)
+        .map((it) => {
+        const [property, value] = it.split(":", 2);
+        return [property.trim(), value ? value.trim() : ""];
+    });
+}
+/**
+ * @internal
+ */
+function parseCssDeclaration(value) {
+    if (!value || value instanceof DynamicValue) {
+        return {};
+    }
+    const pairs = getCSSDeclarations(value);
+    return Object.fromEntries(pairs);
+}
+
 function sliceSize(size, begin, end) {
     if (typeof size !== "number") {
         return size;
@@ -1849,8 +1892,13 @@ exports.NodeClosed = void 0;
     NodeClosed[NodeClosed["VoidSelfClosed"] = 3] = "VoidSelfClosed";
     NodeClosed[NodeClosed["ImplicitClosed"] = 4] = "ImplicitClosed";
 })(exports.NodeClosed || (exports.NodeClosed = {}));
-function isElement(node) {
-    return node.nodeType === NodeType.ELEMENT_NODE;
+/**
+ * Returns true if the node is an element node.
+ *
+ * @public
+ */
+function isElementNode(node) {
+    return Boolean(node && node.nodeType === NodeType.ELEMENT_NODE);
 }
 function isValidTagName(tagName) {
     return Boolean(tagName !== "" && tagName !== "*");
@@ -1924,7 +1972,7 @@ class HtmlElement extends DOMNode {
      * Similar to childNodes but only elements.
      */
     get childElements() {
-        return this.childNodes.filter(isElement);
+        return this.childNodes.filter(isElementNode);
     }
     /**
      * Find the first ancestor matching a selector.
@@ -2154,6 +2202,10 @@ class HtmlElement extends DOMNode {
     get id() {
         return this.getAttributeValue("id");
     }
+    get style() {
+        const attr = this.getAttribute("style");
+        return parseCssDeclaration(attr === null || attr === void 0 ? void 0 : attr.value);
+    }
     /**
      * Returns the first child element or null if there are no child elements.
      */
@@ -2185,8 +2237,9 @@ class HtmlElement extends DOMNode {
         }, []);
     }
     querySelector(selector) {
+        var _a;
         const it = this.querySelectorImpl(selector);
-        return it.next().value || null;
+        return (_a = it.next().value) !== null && _a !== void 0 ? _a : null; // eslint-disable-line @typescript-eslint/no-unsafe-return
     }
     querySelectorAll(selector) {
         const it = this.querySelectorImpl(selector);
@@ -2753,8 +2806,6 @@ var configurationSchema = {
 };
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-const espree = legacyRequire("espree");
-const walk = legacyRequire("acorn-walk");
 function joinTemplateLiteral(nodes) {
     let offset = nodes[0].start + 1;
     let output = "";
@@ -2870,7 +2921,7 @@ class TemplateExtractor {
     }
     static fromFilename(filename) {
         const source = fs__default["default"].readFileSync(filename, "utf-8");
-        const ast = espree.parse(source, {
+        const ast = espree__namespace.parse(source, {
             ecmaVersion: 2017,
             sourceType: "module",
             loc: true,
@@ -2889,7 +2940,7 @@ class TemplateExtractor {
      * `Source`. Defauls to `"inline"`.
      */
     static fromString(source, filename) {
-        const ast = espree.parse(source, {
+        const ast = espree__namespace.parse(source, {
             ecmaVersion: 2017,
             sourceType: "module",
             loc: true,
@@ -2935,7 +2986,8 @@ class TemplateExtractor {
     extractObjectProperty(key) {
         const result = [];
         const { filename, data } = this;
-        walk.simple(this.ast, {
+        const node = this.ast;
+        walk__namespace.simple(node, {
             Property(node) {
                 if (compareKey(node.key, key, filename)) {
                     const source = extractLiteral(node.value, filename, data);
@@ -2959,7 +3011,7 @@ var TRANSFORMER_API;
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "6.6.1";
+const version = "6.8.0";
 /** @public */
 const homepage = "https://html-validate.org";
 /** @public */
@@ -3280,7 +3332,7 @@ function ruleDocumentationUrl(filename) {
     return `${homepage}/rules/${normalized}.html`;
 }
 
-const defaults$p = {
+const defaults$q = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3324,7 +3376,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3603,7 +3655,7 @@ class CaseStyle {
             default: {
                 const last = names.slice(-1);
                 const rest = names.slice(0, -1);
-                return `${rest.join(", ")} or ${last}`;
+                return `${rest.join(", ")} or ${last[0]}`;
             }
         }
     }
@@ -3619,19 +3671,19 @@ class CaseStyle {
                 case "camelcase":
                     return { pattern: /^[a-z][A-Za-z]*$/, name: "camelCase" };
                 default:
-                    throw new ConfigError(`Invalid style "${style}" for ${ruleId} rule`);
+                    throw new ConfigError(`Invalid style "${cur}" for ${ruleId} rule`);
             }
         });
     }
 }
 
-const defaults$o = {
+const defaults$p = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -3658,8 +3710,11 @@ class AttrCase extends Rule {
         };
     }
     documentation() {
+        const { style } = this.options;
         return {
-            description: `Attribute name must be ${this.options.style}.`,
+            description: Array.isArray(style)
+                ? [`Attribute name must be in one of:`, "", ...style.map((it) => `- ${it}`)].join("\n")
+                : `Attribute name must be in ${style}.`,
             url: ruleDocumentationUrl("@/rules/attr-case.ts"),
         };
     }
@@ -3690,7 +3745,7 @@ class AttrCase extends Rule {
     }
 }
 
-exports.TokenType = void 0;
+var TokenType;
 (function (TokenType) {
     TokenType[TokenType["UNICODE_BOM"] = 1] = "UNICODE_BOM";
     TokenType[TokenType["WHITESPACE"] = 2] = "WHITESPACE";
@@ -3709,7 +3764,7 @@ exports.TokenType = void 0;
     TokenType[TokenType["CONDITIONAL"] = 15] = "CONDITIONAL";
     TokenType[TokenType["DIRECTIVE"] = 16] = "DIRECTIVE";
     TokenType[TokenType["EOF"] = 17] = "EOF";
-})(exports.TokenType || (exports.TokenType = {}));
+})(TokenType || (TokenType = {}));
 
 /* eslint-disable no-useless-escape */
 const MATCH_UNICODE_BOM = /^\uFEFF/;
@@ -3788,7 +3843,7 @@ class Lexer {
             previousState = context.state;
             previousLength = context.string.length;
         }
-        yield this.token(context, exports.TokenType.EOF, []);
+        yield this.token(context, TokenType.EOF, []);
     }
     token(context, type, data) {
         const size = data.length > 0 ? data[0].length : 0;
@@ -3859,21 +3914,21 @@ class Lexer {
     }
     *tokenizeInitial(context) {
         yield* this.match(context, [
-            [MATCH_UNICODE_BOM, State.INITIAL, exports.TokenType.UNICODE_BOM],
+            [MATCH_UNICODE_BOM, State.INITIAL, TokenType.UNICODE_BOM],
             [MATCH_XML_TAG, State.INITIAL, false],
-            [MATCH_DOCTYPE_OPEN, State.DOCTYPE, exports.TokenType.DOCTYPE_OPEN],
-            [MATCH_WHITESPACE, State.INITIAL, exports.TokenType.WHITESPACE],
-            [MATCH_DIRECTIVE, State.INITIAL, exports.TokenType.DIRECTIVE],
-            [MATCH_CONDITIONAL, State.INITIAL, exports.TokenType.CONDITIONAL],
-            [MATCH_COMMENT, State.INITIAL, exports.TokenType.COMMENT],
+            [MATCH_DOCTYPE_OPEN, State.DOCTYPE, TokenType.DOCTYPE_OPEN],
+            [MATCH_WHITESPACE, State.INITIAL, TokenType.WHITESPACE],
+            [MATCH_DIRECTIVE, State.INITIAL, TokenType.DIRECTIVE],
+            [MATCH_CONDITIONAL, State.INITIAL, TokenType.CONDITIONAL],
+            [MATCH_COMMENT, State.INITIAL, TokenType.COMMENT],
             [false, State.TEXT, false],
         ], "expected doctype");
     }
     *tokenizeDoctype(context) {
         yield* this.match(context, [
-            [MATCH_WHITESPACE, State.DOCTYPE, exports.TokenType.WHITESPACE],
-            [MATCH_DOCTYPE_VALUE, State.DOCTYPE, exports.TokenType.DOCTYPE_VALUE],
-            [MATCH_DOCTYPE_CLOSE, State.TEXT, exports.TokenType.DOCTYPE_CLOSE],
+            [MATCH_WHITESPACE, State.DOCTYPE, TokenType.WHITESPACE],
+            [MATCH_DOCTYPE_VALUE, State.DOCTYPE, TokenType.DOCTYPE_VALUE],
+            [MATCH_DOCTYPE_CLOSE, State.TEXT, TokenType.DOCTYPE_CLOSE],
         ], "expected doctype name");
     }
     *tokenizeTag(context) {
@@ -3900,30 +3955,30 @@ class Lexer {
             }
         }
         yield* this.match(context, [
-            [MATCH_TAG_CLOSE, nextState, exports.TokenType.TAG_CLOSE],
-            [MATCH_ATTR_START, State.ATTR, exports.TokenType.ATTR_NAME],
-            [MATCH_WHITESPACE, State.TAG, exports.TokenType.WHITESPACE],
+            [MATCH_TAG_CLOSE, nextState, TokenType.TAG_CLOSE],
+            [MATCH_ATTR_START, State.ATTR, TokenType.ATTR_NAME],
+            [MATCH_WHITESPACE, State.TAG, TokenType.WHITESPACE],
         ], 'expected attribute, ">" or "/>"');
     }
     *tokenizeAttr(context) {
         yield* this.match(context, [
-            [MATCH_ATTR_SINGLE, State.TAG, exports.TokenType.ATTR_VALUE],
-            [MATCH_ATTR_DOUBLE, State.TAG, exports.TokenType.ATTR_VALUE],
-            [MATCH_ATTR_UNQUOTED, State.TAG, exports.TokenType.ATTR_VALUE],
+            [MATCH_ATTR_SINGLE, State.TAG, TokenType.ATTR_VALUE],
+            [MATCH_ATTR_DOUBLE, State.TAG, TokenType.ATTR_VALUE],
+            [MATCH_ATTR_UNQUOTED, State.TAG, TokenType.ATTR_VALUE],
             [false, State.TAG, false],
         ], 'expected attribute, ">" or "/>"');
     }
     *tokenizeText(context) {
         yield* this.match(context, [
-            [MATCH_WHITESPACE, State.TEXT, exports.TokenType.WHITESPACE],
+            [MATCH_WHITESPACE, State.TEXT, TokenType.WHITESPACE],
             [MATCH_CDATA_BEGIN, State.CDATA, false],
-            [MATCH_DIRECTIVE, State.TEXT, exports.TokenType.DIRECTIVE],
-            [MATCH_CONDITIONAL, State.TEXT, exports.TokenType.CONDITIONAL],
-            [MATCH_COMMENT, State.TEXT, exports.TokenType.COMMENT],
-            [MATCH_TEMPLATING, State.TEXT, exports.TokenType.TEMPLATING],
-            [MATCH_TAG_OPEN, State.TAG, exports.TokenType.TAG_OPEN],
-            [MATCH_TEXT, State.TEXT, exports.TokenType.TEXT],
-            [MATCH_TAG_LOOKAHEAD, State.TEXT, exports.TokenType.TEXT],
+            [MATCH_DIRECTIVE, State.TEXT, TokenType.DIRECTIVE],
+            [MATCH_CONDITIONAL, State.TEXT, TokenType.CONDITIONAL],
+            [MATCH_COMMENT, State.TEXT, TokenType.COMMENT],
+            [MATCH_TEMPLATING, State.TEXT, TokenType.TEMPLATING],
+            [MATCH_TAG_OPEN, State.TAG, TokenType.TAG_OPEN],
+            [MATCH_TEXT, State.TEXT, TokenType.TEXT],
+            [MATCH_TAG_LOOKAHEAD, State.TEXT, TokenType.TEXT],
         ], 'expected text or "<"');
     }
     *tokenizeCDATA(context) {
@@ -3931,26 +3986,26 @@ class Lexer {
     }
     *tokenizeScript(context) {
         yield* this.match(context, [
-            [MATCH_SCRIPT_END, State.TAG, exports.TokenType.TAG_OPEN],
-            [MATCH_SCRIPT_DATA, State.SCRIPT, exports.TokenType.SCRIPT],
+            [MATCH_SCRIPT_END, State.TAG, TokenType.TAG_OPEN],
+            [MATCH_SCRIPT_DATA, State.SCRIPT, TokenType.SCRIPT],
         ], "expected </script>");
     }
     *tokenizeStyle(context) {
         yield* this.match(context, [
-            [MATCH_STYLE_END, State.TAG, exports.TokenType.TAG_OPEN],
-            [MATCH_STYLE_DATA, State.STYLE, exports.TokenType.STYLE],
+            [MATCH_STYLE_END, State.TAG, TokenType.TAG_OPEN],
+            [MATCH_STYLE_DATA, State.STYLE, TokenType.STYLE],
         ], "expected </style>");
     }
 }
 
 const whitespace = /(\s+)/;
 function isRelevant$3(event) {
-    return event.type === exports.TokenType.ATTR_VALUE;
+    return event.type === TokenType.ATTR_VALUE;
 }
 class AttrDelimiter extends Rule {
     documentation() {
         return {
-            description: `Attribute value should be separated by `,
+            description: `Attribute value must not be separated by whitespace.`,
             url: ruleDocumentationUrl("@/rules/attr-delimiter.ts"),
         };
     }
@@ -3967,7 +4022,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$n = {
+const defaults$o = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4004,7 +4059,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4064,13 +4119,13 @@ var QuoteStyle;
     QuoteStyle["DOUBLE_QUOTE"] = "\"";
     QuoteStyle["AUTO_QUOTE"] = "auto";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$m = {
+const defaults$n = {
     style: "auto",
     unquoted: false,
 };
 class AttrQuotes extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     static schema() {
@@ -4149,7 +4204,7 @@ class AttrSpacing extends Rule {
     setup() {
         let previousToken;
         this.on("token", (event) => {
-            if (event.type === exports.TokenType.ATTR_NAME && previousToken !== exports.TokenType.WHITESPACE) {
+            if (event.type === TokenType.ATTR_NAME && previousToken !== TokenType.WHITESPACE) {
                 this.report(null, "No space between attributes", event.location);
             }
             previousToken = event.type;
@@ -4235,12 +4290,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$l = {
+const defaults$m = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4316,12 +4371,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$k = {
+const defaults$l = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4429,12 +4484,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$j = {
+const defaults$k = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$j, ...options });
+        super({ ...defaults$k, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -4460,7 +4515,9 @@ class ClassPattern extends Rule {
             classes.forEach((cur, index) => {
                 if (!cur.match(this.pattern)) {
                     const location = classes.location(index);
-                    this.report(event.target, `Class "${cur}" does not match required pattern "${this.pattern}"`, location);
+                    const pattern = this.pattern.toString();
+                    const message = `Class "${cur}" does not match required pattern "${pattern}"`;
+                    this.report(event.target, message, location);
                 }
             });
         });
@@ -4541,13 +4598,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$i = {
+const defaults$j = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$i, ...options });
+        super({ ...defaults$j, ...options });
     }
     static schema() {
         return {
@@ -4710,12 +4767,12 @@ class NoStyleTag$1 extends Rule {
     }
 }
 
-const defaults$h = {
+const defaults$i = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$h, ...options });
+        super({ ...defaults$i, ...options });
     }
     static schema() {
         return {
@@ -4747,12 +4804,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$g = {
+const defaults$h = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$g, ...options });
+        super({ ...defaults$h, ...options });
         this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -4776,8 +4833,11 @@ class ElementCase extends Rule {
         };
     }
     documentation() {
+        const { style } = this.options;
         return {
-            description: `Element tagname must be ${this.options.style}.`,
+            description: Array.isArray(style)
+                ? [`Element tagname must be in one of:`, "", ...style.map((it) => `- ${it}`)].join("\n")
+                : `Element tagname must be in ${style}.`,
             url: ruleDocumentationUrl("@/rules/element-case.ts"),
         };
     }
@@ -4815,14 +4875,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$f = {
+const defaults$g = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$f, ...options });
+        super({ ...defaults$g, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -4863,7 +4923,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$f.pattern) {
+        if (context.pattern !== defaults$g.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5265,7 +5325,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$e = {
+const defaults$f = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5296,7 +5356,7 @@ function parseMaxInitial(value) {
 }
 class HeadingLevel extends Rule {
     constructor(options) {
-        super({ ...defaults$e, ...options });
+        super({ ...defaults$f, ...options });
         this.stack = [];
         this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
         this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
@@ -5454,12 +5514,12 @@ class HeadingLevel extends Rule {
     }
 }
 
-const defaults$d = {
+const defaults$e = {
     pattern: "kebabcase",
 };
 class IdPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$d, ...options });
+        super({ ...defaults$e, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5478,6 +5538,7 @@ class IdPattern extends Rule {
     }
     setup() {
         this.on("attr", (event) => {
+            var _a;
             if (event.key.toLowerCase() !== "id") {
                 return;
             }
@@ -5486,7 +5547,10 @@ class IdPattern extends Rule {
                 return;
             }
             if (!event.value || !event.value.match(this.pattern)) {
-                this.report(event.target, `ID "${event.value}" does not match required pattern "${this.pattern}"`, event.valueLocation);
+                const value = (_a = event.value) !== null && _a !== void 0 ? _a : "";
+                const pattern = this.pattern.toString();
+                const message = `ID "${value}" does not match required pattern "${pattern}"`;
+                this.report(event.target, message, event.valueLocation);
             }
         });
     }
@@ -5806,12 +5870,12 @@ function findLabelByParent(el) {
     return [];
 }
 
-const defaults$c = {
+const defaults$d = {
     maxlength: 70,
 };
 class LongTitle extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$d, ...options });
         this.maxlength = this.options.maxlength;
     }
     static schema() {
@@ -5958,13 +6022,13 @@ class MultipleLabeledControls extends Rule {
     }
 }
 
-const defaults$b = {
+const defaults$c = {
     include: null,
     exclude: null,
 };
 class NoAutoplay extends Rule {
     constructor(options) {
-        super({ ...defaults$b, ...options });
+        super({ ...defaults$c, ...options });
     }
     documentation(context) {
         const tagName = context ? ` on <${context.tagName}>` : "";
@@ -6205,24 +6269,14 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
     }
 }
 
-const defaults$a = {
+const defaults$b = {
     include: null,
     exclude: null,
     allowedProperties: ["display"],
 };
-function getCSSDeclarations(value) {
-    return value
-        .trim()
-        .split(";")
-        .filter(Boolean)
-        .map((it) => {
-        const [property, value] = it.split(":", 2);
-        return { property: property.trim(), value: value ? value.trim() : undefined };
-    });
-}
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$b, ...options });
     }
     static schema() {
         return {
@@ -6300,18 +6354,15 @@ class NoInlineStyle extends Rule {
         return true;
     }
     allPropertiesAllowed(value) {
-        if (typeof value !== "string") {
-            return false;
-        }
         const allowProperties = this.options.allowedProperties;
         /* quick path: no properties are allowed, no need to check each one individually */
         if (allowProperties.length === 0) {
             return false;
         }
-        const declarations = getCSSDeclarations(value);
+        const declarations = Object.keys(parseCssDeclaration(value));
         return (declarations.length > 0 &&
             declarations.every((it) => {
-                return allowProperties.includes(it.property);
+                return allowProperties.includes(it);
             }));
     }
 }
@@ -6427,24 +6478,24 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$9 = {
+const defaults$a = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
 const unquotedAttrRegexp = /([<>"'=`]|&(?![a-zA-Z0-9#]+;))/g;
 const matchTemplate = /^(<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/s;
-const replacementTable = new Map([
-    ['"', "&quot;"],
-    ["&", "&amp;"],
-    ["'", "&apos;"],
-    ["<", "&lt;"],
-    ["=", "&equals;"],
-    [">", "&gt;"],
-    ["`", "&grave;"],
-]);
+const replacementTable = {
+    '"': "&quot;",
+    "&": "&amp;",
+    "'": "&apos;",
+    "<": "&lt;",
+    "=": "&equals;",
+    ">": "&gt;",
+    "`": "&grave;",
+};
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$9, ...options });
+        super({ ...defaults$a, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -6494,7 +6545,6 @@ class NoRawCharacters extends Rule {
      * @param text - The full text to find unescaped raw characters in.
      * @param location - Location of text.
      * @param regexp - Regexp pattern to match using.
-     * @param ignore - List of characters to ignore for this text.
      */
     findRawChars(node, text, location, regexp) {
         let match;
@@ -6510,7 +6560,7 @@ class NoRawCharacters extends Rule {
                     continue;
                 }
                 /* determine replacement character and location */
-                const replacement = replacementTable.get(char);
+                const replacement = replacementTable[char];
                 const charLocation = sliceLocation(location, match.index, match.index + 1);
                 /* report as error */
                 this.report(node, `Raw "${char}" must be encoded as "${replacement}"`, charLocation);
@@ -6623,13 +6673,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$8 = {
+const defaults$9 = {
     ignoreForeign: true,
     ignoreXML: true,
 };
 class NoSelfClosing extends Rule {
     constructor(options) {
-        super({ ...defaults$8, ...options });
+        super({ ...defaults$9, ...options });
     }
     static schema() {
         return {
@@ -6745,7 +6795,7 @@ class NoUtf8Bom extends Rule {
     }
     setup() {
         const unregister = this.on("token", (event) => {
-            if (event.type === exports.TokenType.UNICODE_BOM) {
+            if (event.type === TokenType.UNICODE_BOM) {
                 this.report(null, "File should be saved without UTF-8 BOM", event.location);
             }
             /* since the BOM must be the very first thing the rule can now be disabled for the rest of the run */
@@ -6762,13 +6812,13 @@ const replacement = {
     reset: '<button type="reset">',
     image: '<button type="button">',
 };
-const defaults$7 = {
+const defaults$8 = {
     include: null,
     exclude: null,
 };
 class PreferButton extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$8, ...options });
     }
     static schema() {
         return {
@@ -6843,7 +6893,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$7 = {
     mapping: {
         article: "article",
         banner: "header",
@@ -6873,7 +6923,7 @@ const defaults$6 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$7, ...options });
     }
     static schema() {
         return {
@@ -6993,7 +7043,7 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$5 = {
+const defaults$6 = {
     target: "all",
 };
 const crossorigin = new RegExp("^(\\w+://|//)"); /* e.g. https:// or // */
@@ -7003,7 +7053,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$5, ...options });
+        super({ ...defaults$6, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7131,6 +7181,175 @@ class SvgFocusable extends Rule {
     }
 }
 
+const defaults$5 = {
+    characters: [
+        { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
+        { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" },
+    ],
+    ignoreClasses: [],
+    ignoreStyle: true,
+};
+function constructRegex(characters) {
+    const disallowed = characters
+        .map((it) => {
+        return it.pattern;
+    })
+        .join("|");
+    const pattern = `(${disallowed})`;
+    /* eslint-disable-next-line security/detect-non-literal-regexp */
+    return new RegExp(pattern, "g");
+}
+function getText(node) {
+    /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+    const match = node.textContent.match(/^(\s*)(.*)$/);
+    const [, leading, text] = match;
+    return [leading.length, text.trimEnd()];
+}
+/**
+ * Node 12 does not support String.matchAll, this simulates it's behavior.
+ */
+function matchAll(text, regexp) {
+    /* eslint-disable-next-line security/detect-non-literal-regexp */
+    const copy = new RegExp(regexp);
+    const matches = [];
+    /* eslint-disable-next-line no-constant-condition */
+    while (true) {
+        const match = copy.exec(text);
+        if (match === null) {
+            break;
+        }
+        matches.push(match);
+    }
+    return matches;
+}
+class TelNonBreaking extends Rule {
+    constructor(options) {
+        super({ ...defaults$5, ...options });
+        this.regex = constructRegex(this.options.characters);
+    }
+    static schema() {
+        return {
+            characters: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        pattern: {
+                            type: "string",
+                        },
+                        replacement: {
+                            type: "string",
+                        },
+                        description: {
+                            type: "string",
+                        },
+                    },
+                },
+            },
+            ignoreClasses: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+            },
+            ignoreStyle: {
+                type: "boolean",
+            },
+        };
+    }
+    documentation(context) {
+        const { characters } = this.options;
+        const replacements = characters.map((it) => {
+            return `  - \`${it.pattern}\` - replace with \`${it.replacement}\` (${it.description}).`;
+        });
+        return {
+            description: [
+                context
+                    ? `The \`${context.pattern}\` character should be replaced with \`${context.replacement}\` character (${context.description}) when used in a telephone number.`
+                    : `Replace this character with a non-breaking version.`,
+                "",
+                "Unless non-breaking characters is used there could be a line break inserted at that character.",
+                "Line breaks make is harder to read and understand the telephone number.",
+                "",
+                "The following characters should be avoided:",
+                "",
+                ...replacements,
+            ].join("\n"),
+            url: ruleDocumentationUrl("@/rules/tel-non-breaking.ts"),
+        };
+    }
+    setup() {
+        this.on("element:ready", this.isRelevant, (event) => {
+            const { target } = event;
+            if (this.isIgnored(target)) {
+                return;
+            }
+            this.walk(target, target);
+        });
+    }
+    isRelevant(event) {
+        const { target } = event;
+        /* should only deal with anchors */
+        if (!target.is("a")) {
+            return false;
+        }
+        /* ignore if anchor does not have tel href */
+        const attr = target.getAttribute("href");
+        if (!attr || !attr.valueMatches(/^tel:/, false)) {
+            return false;
+        }
+        return true;
+    }
+    isIgnoredClass(node) {
+        const { ignoreClasses } = this.options;
+        const { classList } = node;
+        return ignoreClasses.some((it) => classList.contains(it));
+    }
+    isIgnoredStyle(node) {
+        const { ignoreStyle } = this.options;
+        const { style } = node;
+        if (!ignoreStyle) {
+            return false;
+        }
+        if (style["white-space"] === "nowrap" || style["white-space"] === "pre") {
+            return true;
+        }
+        return false;
+    }
+    isIgnored(node) {
+        return this.isIgnoredClass(node) || this.isIgnoredStyle(node);
+    }
+    walk(anchor, node) {
+        for (const child of node.childNodes) {
+            if (isTextNode(child)) {
+                this.detectDisallowed(anchor, child);
+            }
+            else if (isElementNode(child)) {
+                this.walk(anchor, child);
+            }
+        }
+    }
+    detectDisallowed(anchor, node) {
+        const [offset, text] = getText(node);
+        const matches = matchAll(text, this.regex);
+        for (const match of matches) {
+            const detected = match[0];
+            const entry = this.options.characters.find((it) => it.pattern === detected);
+            /* istanbul ignore next: should never happen and cannot be tested, just a sanity check */
+            if (!entry) {
+                throw new Error(`Failed to find entry for "${detected}" when searching text "${text}"`);
+            }
+            const message = `"${detected}" should be replaced with "${entry.replacement}" (${entry.description}) in telephone number`;
+            const begin = offset + match.index;
+            const end = begin + detected.length;
+            const location = sliceLocation(node.location, begin, end);
+            const context = entry;
+            this.report(anchor, message, location, context);
+        }
+    }
+}
+
 function hasAltText(image) {
     const alt = image.getAttribute("alt");
     /* missing or boolean */
@@ -9161,9 +9380,6 @@ function parseStyle$1(name) {
         case "selfclose":
         case "selfclosing":
             return Style$1.AlwaysSelfclose;
-        /* istanbul ignore next: covered by schema validation */
-        default:
-            throw new Error(`Invalid style "${name}" for "void" rule`);
     }
 }
 
@@ -9595,6 +9811,7 @@ const bundledRules = {
     "script-element": ScriptElement,
     "script-type": ScriptType,
     "svg-focusable": SvgFocusable,
+    "tel-non-breaking": TelNonBreaking,
     "text-content": TextContent,
     "unrecognized-char-ref": UnknownCharReference,
     void: Void,
@@ -9691,6 +9908,7 @@ const config$1 = {
         "script-element": "error",
         "script-type": "error",
         "svg-focusable": "off",
+        "tel-non-breaking": "error",
         "text-content": "error",
         "unrecognized-char-ref": "error",
         void: "off",
@@ -9796,7 +10014,8 @@ class ResolvedConfig {
                 });
             }
             catch (err) {
-                throw new NestedError(`When transforming "${source.filename}": ${err.message}`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new NestedError(`When transforming "${source.filename}": ${message}`, err);
             }
         }
         else {
@@ -9872,9 +10091,10 @@ function loadFromFile(filename) {
     }
     /* expand any relative paths */
     for (const key of ["extends", "elements", "plugins"]) {
-        if (!json[key])
+        const value = json[key];
+        if (!value)
             continue;
-        json[key] = json[key].map((ref) => {
+        json[key] = value.map((ref) => {
             return Config.expandRelative(ref, path__default["default"].dirname(filename));
         });
     }
@@ -10032,6 +10252,7 @@ class Config {
     /**
      * Get element metadata.
      */
+    /* eslint-disable-next-line complexity, sonarjs/cognitive-complexity */
     getMetaTable() {
         /* use cached table if it exists */
         if (this.metaTable) {
@@ -10054,7 +10275,7 @@ class Config {
             }
             let filename;
             /* try searching builtin metadata */
-            filename = path__default["default"].join(projectRoot, "elements", `${entry}.json`);
+            filename = path__default["default"].join(projectRoot, "elements", `${entry}.js`);
             if (fs__default["default"].existsSync(filename)) {
                 metaTable.loadFromFile(filename);
                 continue;
@@ -10070,7 +10291,8 @@ class Config {
                 metaTable.loadFromObject(legacyRequire(entry));
             }
             catch (err) {
-                throw new ConfigError(`Failed to load elements from "${entry}": ${err.message}`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new ConfigError(`Failed to load elements from "${entry}": ${message}`, err);
             }
         }
         metaTable.init();
@@ -10146,7 +10368,8 @@ class Config {
                 return plugin;
             }
             catch (err) {
-                throw new ConfigError(`Failed to load plugin "${moduleName}": ${err}`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new ConfigError(`Failed to load plugin "${moduleName}": ${message}`, err);
             }
         });
     }
@@ -10466,7 +10689,7 @@ class ParserError extends Error {
 }
 
 function isAttrValueToken(token) {
-    return Boolean(token && token.type === exports.TokenType.ATTR_VALUE);
+    return Boolean(token && token.type === TokenType.ATTR_VALUE);
 }
 function svgShouldRetainTag(foreignTagName, tagName) {
     return foreignTagName === "svg" && ["title", "desc"].includes(tagName);
@@ -10574,43 +10797,43 @@ class Parser {
     /* eslint-disable-next-line complexity */
     consume(source, token, tokenStream) {
         switch (token.type) {
-            case exports.TokenType.UNICODE_BOM:
+            case TokenType.UNICODE_BOM:
                 /* ignore */
                 break;
-            case exports.TokenType.TAG_OPEN:
+            case TokenType.TAG_OPEN:
                 this.consumeTag(source, token, tokenStream);
                 break;
-            case exports.TokenType.WHITESPACE:
+            case TokenType.WHITESPACE:
                 this.trigger("whitespace", {
                     text: token.data[0],
                     location: token.location,
                 });
                 this.appendText(token.data[0], token.location);
                 break;
-            case exports.TokenType.DIRECTIVE:
+            case TokenType.DIRECTIVE:
                 this.consumeDirective(token);
                 break;
-            case exports.TokenType.CONDITIONAL:
+            case TokenType.CONDITIONAL:
                 this.consumeConditional(token);
                 break;
-            case exports.TokenType.COMMENT:
+            case TokenType.COMMENT:
                 this.consumeComment(token);
                 break;
-            case exports.TokenType.DOCTYPE_OPEN:
+            case TokenType.DOCTYPE_OPEN:
                 this.consumeDoctype(token, tokenStream);
                 break;
-            case exports.TokenType.TEXT:
-            case exports.TokenType.TEMPLATING:
+            case TokenType.TEXT:
+            case TokenType.TEMPLATING:
                 this.appendText(token.data[0], token.location);
                 break;
-            case exports.TokenType.EOF:
+            case TokenType.EOF:
                 this.closeTree(source, token.location);
                 break;
         }
     }
     /* eslint-disable-next-line complexity, sonarjs/cognitive-complexity */
     consumeTag(source, startToken, tokenStream) {
-        const tokens = Array.from(this.consumeUntil(tokenStream, exports.TokenType.TAG_CLOSE, startToken.location));
+        const tokens = Array.from(this.consumeUntil(tokenStream, TokenType.TAG_CLOSE, startToken.location));
         const endToken = tokens.slice(-1)[0];
         const closeOptional = this.closeOptional(startToken);
         const parent = closeOptional ? this.dom.getActive().parent : this.dom.getActive();
@@ -10636,9 +10859,9 @@ class Parser {
         for (let i = 0; i < tokens.length; i++) {
             const token = tokens[i];
             switch (token.type) {
-                case exports.TokenType.WHITESPACE:
+                case TokenType.WHITESPACE:
                     break;
-                case exports.TokenType.ATTR_NAME:
+                case TokenType.ATTR_NAME:
                     this.consumeAttribute(source, node, token, tokens[i + 1]);
                     break;
             }
@@ -10716,7 +10939,7 @@ class Parser {
         let endToken;
         do {
             /* search for tags */
-            const tokens = Array.from(this.consumeUntil(tokenStream, exports.TokenType.TAG_OPEN, errorLocation));
+            const tokens = Array.from(this.consumeUntil(tokenStream, TokenType.TAG_OPEN, errorLocation));
             const [last] = tokens.slice(-1);
             const [, tagClosed, tagName] = last.data;
             /* special case: svg <title> and <desc> should be intact as it affects accessibility */
@@ -10733,7 +10956,7 @@ class Parser {
                 continue;
             }
             /* locate end token and determine if this is a self-closed tag */
-            const endTokens = Array.from(this.consumeUntil(tokenStream, exports.TokenType.TAG_CLOSE, last.location));
+            const endTokens = Array.from(this.consumeUntil(tokenStream, TokenType.TAG_CLOSE, last.location));
             endToken = endTokens.slice(-1)[0];
             const selfClosed = endToken.data[0] === "/>";
             /* since foreign element may be nested keep a count for the number of
@@ -10819,7 +11042,7 @@ class Parser {
      *      ^^^          ^^^         ^^^    (null)   (null)
      */
     getAttributeValueLocation(token) {
-        if (!token || token.type !== exports.TokenType.ATTR_VALUE || token.data[2] === "") {
+        if (!token || token.type !== TokenType.ATTR_VALUE || token.data[2] === "") {
             return null;
         }
         const quote = token.data[3];
@@ -10837,7 +11060,7 @@ class Parser {
     getAttributeLocation(key, value) {
         var _a;
         const begin = key.location;
-        const end = value && value.type === exports.TokenType.ATTR_VALUE ? value.location : undefined;
+        const end = value && value.type === TokenType.ATTR_VALUE ? value.location : undefined;
         return {
             filename: begin.filename,
             line: begin.line,
@@ -10898,7 +11121,7 @@ class Parser {
      * Consumes doctype tokens. Emits doctype event.
      */
     consumeDoctype(startToken, tokenStream) {
-        const tokens = Array.from(this.consumeUntil(tokenStream, exports.TokenType.DOCTYPE_CLOSE, startToken.location));
+        const tokens = Array.from(this.consumeUntil(tokenStream, TokenType.DOCTYPE_CLOSE, startToken.location));
         /* first token is the doctype, second is the closing ">" */
         const doctype = tokens[0];
         const value = doctype.data[0];
@@ -10924,7 +11147,7 @@ class Parser {
                 return;
             it = this.next(tokenStream);
         }
-        throw new ParserError(errorLocation, `stream ended before ${exports.TokenType[search]} token was found`);
+        throw new ParserError(errorLocation, `stream ended before ${TokenType[search]} token was found`);
     }
     /**
      * Consumes tokens until a matching close-tag is found. Tags are appended to
@@ -10938,7 +11161,7 @@ class Parser {
         while (!it.done) {
             const token = it.value;
             this.consume(source, token, tokenStream);
-            if (token.type === exports.TokenType.TAG_OPEN) {
+            if (token.type === TokenType.TAG_OPEN) {
                 const [, close, tagName] = token.data;
                 if (tagName === searchTag) {
                     if (close) {
@@ -11011,6 +11234,12 @@ class Parser {
     }
 }
 
+function freeze(src) {
+    return {
+        ...src,
+        selector: src.selector(),
+    };
+}
 /**
  * @internal
  */
@@ -11062,7 +11291,9 @@ class Reporter {
             line: location.line,
             column: location.column,
             size: location.size || 0,
-            selector: node ? node.generateSelector() : null,
+            selector() {
+                return node ? node.generateSelector() : null;
+            },
             context,
         });
     }
@@ -11076,7 +11307,7 @@ class Reporter {
         const report = {
             valid: this.isValid(),
             results: Object.keys(this.result).map((filePath) => {
-                const messages = Array.from(this.result[filePath]).sort(messageSort);
+                const messages = Array.from(this.result[filePath], freeze).sort(messageSort);
                 const source = (sources || []).find((source) => { var _a; return filePath === ((_a = source.filename) !== null && _a !== void 0 ? _a : ""); });
                 return {
                     filePath,
@@ -11150,7 +11381,7 @@ class Engine {
     /**
      * Lint sources and return report
      *
-     * @param src - Parsed source.
+     * @param sources - Sources to lint.
      * @returns Report output.
      */
     lint(sources) {
@@ -11229,7 +11460,7 @@ class Engine {
             for (const token of lexer.tokenize(src)) {
                 const data = (_a = token.data[0]) !== null && _a !== void 0 ? _a : "";
                 lines.push({
-                    token: exports.TokenType[token.type],
+                    token: TokenType[token.type],
                     data,
                     location: `${token.location.filename}:${token.location.line}:${token.location.column}`,
                 });
@@ -11244,7 +11475,7 @@ class Engine {
         const lines = [];
         function decoration(node) {
             let output = "";
-            if (node.hasAttribute("id")) {
+            if (node.id) {
                 output += `#${node.id}`;
             }
             if (node.hasAttribute("class")) {
@@ -11478,7 +11709,7 @@ class Engine {
             line: location.line,
             column: location.column,
             size: location.size || 0,
-            selector: null,
+            selector: () => null,
         });
     }
 }
@@ -12000,6 +12231,8 @@ const formatter$4 = checkstyleFormatter;
 
 const defaults = {
     showLink: true,
+    showSummary: true,
+    showSelector: false,
 };
 /**
  * Codeframe formatter based on ESLint codeframe.
@@ -12055,6 +12288,7 @@ function getEndLocation(message, source) {
  * @returns The formatted output.
  */
 function formatMessage(message, parentResult, options) {
+    var _a;
     const type = message.severity === 2 ? kleur__default["default"].red("error") : kleur__default["default"].yellow("warning");
     const msg = `${kleur__default["default"].bold(message.message.replace(/([^ ])\.$/, "$1"))}`;
     const ruleId = kleur__default["default"].dim(`(${message.ruleId})`);
@@ -12077,6 +12311,9 @@ function formatMessage(message, parentResult, options) {
             end: getEndLocation(message, sourceCode),
         }, { highlightCode: false }));
     }
+    if (options.showSelector) {
+        result.push(`${kleur__default["default"].bold("Selector:")} ${(_a = message.selector) !== null && _a !== void 0 ? _a : "-"}`);
+    }
     if (options.showLink && message.ruleUrl) {
         result.push(`${kleur__default["default"].bold("Details:")} ${message.ruleUrl}`);
     }
@@ -12114,9 +12351,11 @@ function codeframe(results, options) {
         return resultsOutput.concat(messages);
     }, [])
         .join("\n");
-    output += "\n";
-    output += formatSummary(errors, warnings);
-    output += "\n";
+    if (merged.showSummary) {
+        output += "\n";
+        output += formatSummary(errors, warnings);
+        output += "\n";
+    }
     return errors + warnings > 0 ? output : "";
 }
 const formatter$3 = codeframe;
@@ -12216,6 +12455,7 @@ exports.TemplateExtractor = TemplateExtractor;
 exports.TextNode = TextNode;
 exports.UserError = UserError;
 exports.bugs = bugs;
+exports.codeframe = codeframe;
 exports.compatibilityCheck = compatibilityCheck;
 exports.getFormatter = getFormatter;
 exports.legacyRequire = legacyRequire;