html-validate 6.0.2 → 6.1.3

package/dist/es/core.js

@@ -252,6 +252,9 @@ class NestedError extends Error {
     }
 }
 
+/**
+ * @public
+ */
 class UserError extends NestedError {
 }
 
@@ -262,6 +265,9 @@ function getSummary(schema, obj, errors) {
     // istanbul ignore next: for safety only
     return output.length > 0 ? output[0].error : "unknown validation error";
 }
+/**
+ * @public
+ */
 class SchemaValidationError extends UserError {
     constructor(filename, message, obj, schema, errors) {
         const summary = getSummary(schema, obj, errors);
@@ -695,6 +701,8 @@ var TextContent$1;
 /**
  * Properties listed here can be copied (loaded) onto another element using
  * [[HtmlElement.loadMeta]].
+ *
+ * @public
  */
 const MetaCopyableProperty = [
     "metadata",
@@ -835,16 +843,27 @@ const ajvRegexpKeyword = {
     errors: true,
     validate: ajvRegexpValidate,
 };
+/**
+ * @public
+ */
 class MetaTable {
+    /**
+     * @internal
+     */
     constructor() {
         this.elements = {};
         this.schema = clone(schema);
     }
+    /**
+     * @internal
+     */
     init() {
         this.resolveGlobal();
     }
     /**
      * Extend validation schema.
+     *
+     * @internal
      */
     extendValidationSchema(patch) {
         if (patch.properties) {
@@ -865,6 +884,7 @@ class MetaTable {
     /**
      * Load metadata table from object.
      *
+     * @internal
      * @param obj - Object with metadata to load
      * @param filename - Optional filename used when presenting validation error
      */
@@ -885,6 +905,7 @@ class MetaTable {
     /**
      * Load metadata table from filename
      *
+     * @internal
      * @param filename - Filename to load
      */
     loadFromFile(filename) {
@@ -903,6 +924,7 @@ class MetaTable {
     /**
      * Get [[MetaElement]] for the given tag or null if the element doesn't exist.
      *
+     * @public
      * @returns A shallow copy of metadata.
      */
     getMetaFor(tagName) {
@@ -911,6 +933,8 @@ class MetaTable {
     }
     /**
      * Find all tags which has enabled given property.
+     *
+     * @public
      */
     getTagsWithProperty(propName) {
         return Object.entries(this.elements)
@@ -919,6 +943,8 @@ class MetaTable {
     }
     /**
      * Find tag matching tagName or inheriting from it.
+     *
+     * @public
      */
     getTagsDerivedFrom(tagName) {
         return Object.entries(this.elements)
@@ -950,6 +976,9 @@ class MetaTable {
         ajv.addKeyword({ keyword: "copyable" });
         return ajv.compile(this.schema);
     }
+    /**
+     * @public
+     */
     getJSONSchema() {
         return this.schema;
     }
@@ -985,6 +1014,9 @@ class MetaTable {
         merged.attributes = Object.fromEntries(filteredAttrs);
         return merged;
     }
+    /**
+     * @internal
+     */
     resolve(node) {
         if (node.meta) {
             expandProperties(node, node.meta);
@@ -1079,6 +1111,9 @@ function matchAttribute(node, match) {
     }
 }
 
+/**
+ * @public
+ */
 class DynamicValue {
     constructor(expr) {
         this.expr = expr;
@@ -1195,12 +1230,14 @@ var State;
     State[State["ATTR"] = 5] = "ATTR";
     State[State["CDATA"] = 6] = "CDATA";
     State[State["SCRIPT"] = 7] = "SCRIPT";
+    State[State["STYLE"] = 8] = "STYLE";
 })(State || (State = {}));
 
 var ContentModel;
 (function (ContentModel) {
     ContentModel[ContentModel["TEXT"] = 1] = "TEXT";
     ContentModel[ContentModel["SCRIPT"] = 2] = "SCRIPT";
+    ContentModel[ContentModel["STYLE"] = 3] = "STYLE";
 })(ContentModel || (ContentModel = {}));
 class Context {
     constructor(source) {
@@ -1729,6 +1766,8 @@ const TEXT_NODE_NAME = "#text";
  *
  * Text nodes are appended as children of `HtmlElement` and cannot have childen
  * of its own.
+ *
+ * @public
  */
 class TextNode extends DOMNode {
     /**
@@ -1760,6 +1799,9 @@ class TextNode extends DOMNode {
     }
 }
 
+/**
+ * @public
+ */
 var NodeClosed;
 (function (NodeClosed) {
     NodeClosed[NodeClosed["Open"] = 0] = "Open";
@@ -1774,6 +1816,9 @@ function isElement(node) {
 function isValidTagName(tagName) {
     return Boolean(tagName !== "" && tagName !== "*");
 }
+/**
+ * @public
+ */
 class HtmlElement extends DOMNode {
     constructor(tagName, parent, closed, meta, location) {
         const nodeType = tagName ? NodeType.ELEMENT_NODE : NodeType.DOCUMENT_NODE;
@@ -1799,9 +1844,15 @@ class HtmlElement extends DOMNode {
             }
         }
     }
+    /**
+     * @internal
+     */
     static rootNode(location) {
         return new HtmlElement(undefined, null, NodeClosed.EndTag, null, location);
     }
+    /**
+     * @internal
+     */
     static fromTokens(startToken, endToken, parent, metaTable) {
         const tagName = startToken.data[2];
         if (!tagName) {
@@ -2111,6 +2162,8 @@ class HtmlElement extends DOMNode {
     }
     /**
      * Visit all nodes from this node and down. Depth first.
+     *
+     * @internal
      */
     visitDepthFirst(callback) {
         function visit(node) {
@@ -2123,6 +2176,8 @@ class HtmlElement extends DOMNode {
     }
     /**
      * Evaluates callbackk on all descendants, returning true if any are true.
+     *
+     * @internal
      */
     someChildren(callback) {
         return this.childElements.some(visit);
@@ -2137,6 +2192,8 @@ class HtmlElement extends DOMNode {
     }
     /**
      * Evaluates callbackk on all descendants, returning true if all are true.
+     *
+     * @internal
      */
     everyChildren(callback) {
         return this.childElements.every(visit);
@@ -2151,6 +2208,8 @@ class HtmlElement extends DOMNode {
      * Visit all nodes from this node and down. Breadth first.
      *
      * The first node for which the callback evaluates to true is returned.
+     *
+     * @internal
      */
     find(callback) {
         function visit(node) {
@@ -2758,6 +2817,9 @@ function compareKey(node, key, filename) {
         }
     }
 }
+/**
+ * @public
+ */
 class TemplateExtractor {
     constructor(ast, filename, data) {
         this.ast = ast;
@@ -2851,19 +2913,28 @@ var TRANSFORMER_API;
     TRANSFORMER_API[TRANSFORMER_API["VERSION"] = 1] = "VERSION";
 })(TRANSFORMER_API || (TRANSFORMER_API = {}));
 
+/* generated file, changes will be overwritten */
+/** @public */
 const name = "html-validate";
-const version = "6.0.2";
+/** @public */
+const version = "6.1.3";
+/** @public */
 const homepage = "https://html-validate.org";
-const bugs = {
-	url: "https://gitlab.com/html-validate/html-validate/issues/new"
-};
+/** @public */
+const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
+/**
+ * @public
+ */
 var Severity;
 (function (Severity) {
     Severity[Severity["DISABLED"] = 0] = "DISABLED";
     Severity[Severity["WARN"] = 1] = "WARN";
     Severity[Severity["ERROR"] = 2] = "ERROR";
 })(Severity || (Severity = {}));
+/**
+ * @internal
+ */
 function parseSeverity(value) {
     switch (value) {
         case 0:
@@ -2911,6 +2982,9 @@ function getSchemaValidator(ruleId, properties) {
     };
     return ajv$1.compile(schema);
 }
+/**
+ * @public
+ */
 class Rule {
     constructor(options) {
         /* faux initialization, properly initialized by init(). This is to keep TS happy without adding null-checks everywhere */
@@ -3112,6 +3186,9 @@ class Rule {
         return null;
     }
 }
+/**
+ * @internal
+ */
 function ruleDocumentationUrl(filename) {
     /* during bundling all "@/rule.ts"'s are converted to paths relative to the src
      * folder and with the @/ prefix, by replacing the @ with the dist folder we
@@ -3142,24 +3219,60 @@ const description = {
     ["absolute" /* ABSOLUTE */]: "Absolute links are not allowed by current configuration.",
     ["anchor" /* ANCHOR */]: null,
 };
+function parseAllow(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return {
+        /* eslint-disable security/detect-non-literal-regexp */
+        include: value.include ? value.include.map((it) => new RegExp(it)) : null,
+        exclude: value.exclude ? value.exclude.map((it) => new RegExp(it)) : null,
+        /* eslint-enable security/detect-non-literal-regexp */
+    };
+}
+/**
+ * @internal
+ */
+function matchList(value, list) {
+    if (list.include && !list.include.some((it) => it.test(value))) {
+        return false;
+    }
+    if (list.exclude && list.exclude.some((it) => it.test(value))) {
+        return false;
+    }
+    return true;
+}
 class AllowedLinks extends Rule {
     constructor(options) {
         super({ ...defaults$p, ...options });
+        this.allowExternal = parseAllow(this.options.allowExternal);
+        this.allowRelative = parseAllow(this.options.allowRelative);
+        this.allowAbsolute = parseAllow(this.options.allowAbsolute);
     }
     static schema() {
+        const booleanOrObject = {
+            anyOf: [
+                { type: "boolean" },
+                {
+                    type: "object",
+                    properties: {
+                        include: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                        exclude: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                    },
+                },
+            ],
+        };
         return {
-            allowAbsolute: {
-                type: "boolean",
-            },
-            allowBase: {
-                type: "boolean",
-            },
-            allowExternal: {
-                type: "boolean",
-            },
-            allowRelative: {
-                type: "boolean",
-            },
+            allowExternal: { ...booleanOrObject },
+            allowRelative: { ...booleanOrObject },
+            allowAbsolute: { ...booleanOrObject },
+            allowBase: { type: "boolean" },
         };
     }
     documentation(context) {
@@ -3181,16 +3294,16 @@ class AllowedLinks extends Rule {
                     /* anchor links are always allowed by this rule */
                     break;
                 case "absolute" /* ABSOLUTE */:
-                    this.handleAbsolute(event, style);
+                    this.handleAbsolute(link, event, style);
                     break;
                 case "external" /* EXTERNAL */:
-                    this.handleExternal(event, style);
+                    this.handleExternal(link, event, style);
                     break;
                 case "relative-base" /* RELATIVE_BASE */:
-                    this.handleRelativeBase(event, style);
+                    this.handleRelativeBase(link, event, style);
                     break;
                 case "relative-path" /* RELATIVE_PATH */:
-                    this.handleRelativePath(event, style);
+                    this.handleRelativePath(link, event, style);
                     break;
             }
         });
@@ -3224,28 +3337,49 @@ class AllowedLinks extends Rule {
                 return "relative-base" /* RELATIVE_BASE */;
         }
     }
-    handleAbsolute(event, style) {
-        const { allowAbsolute } = this.options;
-        if (!allowAbsolute) {
+    handleAbsolute(target, event, style) {
+        const { allowAbsolute } = this;
+        if (allowAbsolute === true) {
+            return;
+        }
+        else if (allowAbsolute === false) {
             this.report(event.target, "Link destination must not be absolute url", event.valueLocation, style);
         }
+        else if (!matchList(target, allowAbsolute)) {
+            this.report(event.target, "Absolute link to this destination is not allowed by current configuration", event.valueLocation, style);
+        }
     }
-    handleExternal(event, style) {
-        const { allowExternal } = this.options;
-        if (!allowExternal) {
+    handleExternal(target, event, style) {
+        const { allowExternal } = this;
+        if (allowExternal === true) {
+            return;
+        }
+        else if (allowExternal === false) {
             this.report(event.target, "Link destination must not be external url", event.valueLocation, style);
         }
+        else if (!matchList(target, allowExternal)) {
+            this.report(event.target, "External link to this destination is not allowed by current configuration", event.valueLocation, style);
+        }
     }
-    handleRelativePath(event, style) {
-        const { allowRelative } = this.options;
-        if (!allowRelative) {
+    handleRelativePath(target, event, style) {
+        const { allowRelative } = this;
+        if (allowRelative === true) {
+            return false;
+        }
+        else if (allowRelative === false) {
             this.report(event.target, "Link destination must not be relative url", event.valueLocation, style);
+            return true;
         }
+        else if (!matchList(target, allowRelative)) {
+            this.report(event.target, "Relative link to this destination is not allowed by current configuration", event.valueLocation, style);
+            return true;
+        }
+        return false;
     }
-    handleRelativeBase(event, style) {
-        const { allowRelative, allowBase } = this.options;
-        if (!allowRelative) {
-            this.report(event.target, "Link destination must not be relative url", event.valueLocation, style);
+    handleRelativeBase(target, event, style) {
+        const { allowBase } = this.options;
+        if (this.handleRelativePath(target, event, style)) {
+            return;
         }
         else if (!allowBase) {
             this.report(event.target, "Relative links must be relative to current folder", event.valueLocation, style);
@@ -3329,6 +3463,9 @@ class AriaLabelMisuse extends Rule {
     }
 }
 
+/**
+ * @public
+ */
 class ConfigError extends UserError {
 }
 
@@ -3466,10 +3603,11 @@ var TokenType;
     TokenType[TokenType["TEXT"] = 11] = "TEXT";
     TokenType[TokenType["TEMPLATING"] = 12] = "TEMPLATING";
     TokenType[TokenType["SCRIPT"] = 13] = "SCRIPT";
-    TokenType[TokenType["COMMENT"] = 14] = "COMMENT";
-    TokenType[TokenType["CONDITIONAL"] = 15] = "CONDITIONAL";
-    TokenType[TokenType["DIRECTIVE"] = 16] = "DIRECTIVE";
-    TokenType[TokenType["EOF"] = 17] = "EOF";
+    TokenType[TokenType["STYLE"] = 14] = "STYLE";
+    TokenType[TokenType["COMMENT"] = 15] = "COMMENT";
+    TokenType[TokenType["CONDITIONAL"] = 16] = "CONDITIONAL";
+    TokenType[TokenType["DIRECTIVE"] = 17] = "DIRECTIVE";
+    TokenType[TokenType["EOF"] = 18] = "EOF";
 })(TokenType || (TokenType = {}));
 
 /* eslint-disable no-useless-escape */
@@ -3482,7 +3620,7 @@ const MATCH_XML_TAG = /^<\?xml.*?\?>\s+/;
 const MATCH_TAG_OPEN = /^<(\/?)([a-zA-Z0-9\-:]+)/; // https://www.w3.org/TR/html/syntax.html#start-tags
 const MATCH_TAG_CLOSE = /^\/?>/;
 const MATCH_TEXT = /^[^]*?(?=(?:[ \t]*(?:\r\n|\r|\n)|<[^ ]|$))/;
-const MATCH_TEMPLATING = /^(?:<%.*?%>|<\?.*?\?>|<\$.*?\$>)/;
+const MATCH_TEMPLATING = /^(?:<%.*?%>|<\?.*?\?>|<\$.*?\$>)/s;
 const MATCH_TAG_LOOKAHEAD = /^[^]*?(?=<|$)/;
 const MATCH_ATTR_START = /^([^\t\r\n\f \/><"'=]+)/; // https://www.w3.org/TR/html/syntax.html#elements-attributes
 const MATCH_ATTR_SINGLE = /^(\s*=\s*)'([^']*?)(')/;
@@ -3492,6 +3630,8 @@ const MATCH_CDATA_BEGIN = /^<!\[CDATA\[/;
 const MATCH_CDATA_END = /^[^]*?]]>/;
 const MATCH_SCRIPT_DATA = /^[^]*?(?=<\/script)/;
 const MATCH_SCRIPT_END = /^<(\/)(script)/;
+const MATCH_STYLE_DATA = /^[^]*?(?=<\/style)/;
+const MATCH_STYLE_END = /^<(\/)(style)/;
 const MATCH_DIRECTIVE = /^<!--\s*\[html-validate-(.*?)]\s*-->/;
 const MATCH_COMMENT = /^<!--([^]*?)-->/;
 const MATCH_CONDITIONAL = /^<!\[([^\]]*?)\]>/;
@@ -3531,6 +3671,9 @@ class Lexer {
                 case State.SCRIPT:
                     yield* this.tokenizeScript(context);
                     break;
+                case State.STYLE:
+                    yield* this.tokenizeStyle(context);
+                    break;
                 /* istanbul ignore next: sanity check: should not happen unless adding new states */
                 default:
                     this.unhandled(context);
@@ -3599,11 +3742,14 @@ class Lexer {
      * Called when entering a new state.
      */
     enter(context, state, data) {
-        /* script tags require a different content model */
+        /* script/style tags require a different content model */
         if (state === State.TAG && data && data[0][0] === "<") {
             if (data[0] === "<script") {
                 context.contentModel = ContentModel.SCRIPT;
             }
+            else if (data[0] === "<style") {
+                context.contentModel = ContentModel.STYLE;
+            }
             else {
                 context.contentModel = ContentModel.TEXT;
             }
@@ -3629,6 +3775,7 @@ class Lexer {
         ], "expected doctype name");
     }
     *tokenizeTag(context) {
+        /* eslint-disable-next-line consistent-return -- exhaustive switch handled by typescript */
         function nextState(token) {
             switch (context.contentModel) {
                 case ContentModel.TEXT:
@@ -3640,11 +3787,14 @@ class Lexer {
                     else {
                         return State.TEXT; /* <script/> (not legal but handle it anyway so the lexer doesn't choke on it) */
                     }
+                case ContentModel.STYLE:
+                    if (token && token.data[0][0] !== "/") {
+                        return State.STYLE;
+                    }
+                    else {
+                        return State.TEXT; /* <style/> */
+                    }
             }
-            /* istanbul ignore next: not covered by a test as there is currently no
-             * way to trigger this unless new content models are added but this will
-             * add a saner default if anyone ever does */
-            return context.contentModel !== ContentModel.SCRIPT ? State.TEXT : State.SCRIPT;
         }
         yield* this.match(context, [
             [MATCH_TAG_CLOSE, nextState, TokenType.TAG_CLOSE],
@@ -3682,6 +3832,12 @@ class Lexer {
             [MATCH_SCRIPT_DATA, State.SCRIPT, TokenType.SCRIPT],
         ], "expected </script>");
     }
+    *tokenizeStyle(context) {
+        yield* this.match(context, [
+            [MATCH_STYLE_END, State.TAG, TokenType.TAG_OPEN],
+            [MATCH_STYLE_DATA, State.STYLE, TokenType.STYLE],
+        ], "expected </style>");
+    }
 }
 
 const whitespace = /(\s+)/;
@@ -5932,7 +6088,7 @@ function getCSSDeclarations(value) {
         .filter(Boolean)
         .map((it) => {
         const [property, value] = it.split(":", 2);
-        return { property: property.trim(), value: value.trim() };
+        return { property: property.trim(), value: value ? value.trim() : undefined };
     });
 }
 class NoInlineStyle extends Rule {
@@ -6147,7 +6303,7 @@ const defaults$9 = {
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
 const unquotedAttrRegexp = /([<>"'=`]|&(?![a-zA-Z0-9#]+;))/g;
-const matchTemplate = /^(<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/;
+const matchTemplate = /^(<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/s;
 const replacementTable = new Map([
     ['"', "&quot;"],
     ["&", "&amp;"],
@@ -9447,6 +9603,9 @@ const config = {
     },
 };
 
+/**
+ * @internal
+ */
 const presets = {
     "html-validate:a17y": config$3,
     "html-validate:document": config$2,
@@ -9594,8 +9753,13 @@ function loadFromFile(filename) {
  * Configuration holder.
  *
  * Each file being validated will have a unique instance of this class.
+ *
+ * @public
  */
 class Config {
+    /**
+     * @internal
+     */
     constructor(options) {
         var _a;
         this.transformers = [];
@@ -9658,6 +9822,8 @@ class Config {
      * Validate configuration data.
      *
      * Throws SchemaValidationError if invalid.
+     *
+     * @internal
      */
     static validate(configData, filename = null) {
         var _a;
@@ -9685,6 +9851,8 @@ class Config {
      *
      * Must be called before trying to use config. Can safely be called multiple
      * times.
+     *
+     * @internal
      */
     init() {
         if (this.initialized) {
@@ -9704,6 +9872,7 @@ class Config {
      * Returns a new configuration as a merge of the two. Entries from the passed
      * object takes priority over this object.
      *
+     * @internal
      * @param rhs - Configuration to merge with this one.
      */
     merge(rhs) {
@@ -9796,6 +9965,8 @@ class Config {
     }
     /**
      * Get all configured rules, their severity and options.
+     *
+     * @internal
      */
     getRules() {
         var _a;
@@ -9818,6 +9989,8 @@ class Config {
     }
     /**
      * Get all configured plugins.
+     *
+     * @internal
      */
     getPlugins() {
         return this.plugins;
@@ -9883,6 +10056,8 @@ class Config {
      *
      * A resolved configuration will merge all extended configs and load all
      * plugins and transformers, and normalize the rest of the configuration.
+     *
+     * @internal
      */
     resolve() {
         return new ResolvedConfig(this.resolveData());
@@ -10067,6 +10242,9 @@ class ConfigLoader {
     }
 }
 
+/**
+ * @internal
+ */
 class EventHandler {
     constructor() {
         this.listeners = {};
@@ -10147,6 +10325,8 @@ class ParserError extends Error {
 
 /**
  * Parse HTML document into a DOM tree.
+ *
+ * @internal
  */
 class Parser {
     /**
@@ -10623,6 +10803,9 @@ class Parser {
     }
 }
 
+/**
+ * @internal
+ */
 class Reporter {
     constructor() {
         this.result = {};
@@ -10741,6 +10924,9 @@ function messageSort(a, b) {
     return 0;
 }
 
+/**
+ * @internal
+ */
 class Engine {
     constructor(config, ParserClass) {
         this.report = new Reporter();
@@ -11094,6 +11280,8 @@ class Engine {
  *
  * In practice this means no configuration is fetch by traversing the
  * filesystem.
+ *
+ * @public
  */
 class StaticConfigLoader extends ConfigLoader {
     getConfigFor(handle, configOverride) {
@@ -11133,6 +11321,8 @@ function isConfigData(value) {
  * Primary API for using HTML-validate.
  *
  * Provides high-level abstractions for common operations.
+ *
+ * @public
  */
 class HtmlValidate {
     constructor(arg) {
@@ -11337,6 +11527,7 @@ class HtmlValidate {
     /**
      * Create a parser configured for given filename.
      *
+     * @internal
      * @param source - Source to use.
      */
     getParserFor(source) {
@@ -11380,6 +11571,7 @@ const defaults$1 = {
  * Tests if plugin is compatible with html-validate library. Unless the `silent`
  * option is used a warning is displayed on the console.
  *
+ * @public
  * @param name - Name of plugin
  * @param declared - What library versions the plugin support (e.g. declared peerDependencies)
  * @returns - `true` if version is compatible
@@ -11408,6 +11600,7 @@ const ruleIds = new Set(Object.keys(bundledRules));
  * Can be used to create forward/backward compatibility by checking if a rule
  * exists to enable/disable it.
  *
+ * @public
  * @param ruleId - Rule id to check
  * @returns `true` if rule exists
  */
@@ -11447,6 +11640,8 @@ function findConfigurationFiles(directory) {
  * 2. If set in the global config the override is merged into global and
  * returned. No configuration files are searched.
  * 3. Setting `root` in configuration file only stops directory traversal.
+ *
+ * @public
  */
 class FileSystemConfigLoader extends ConfigLoader {
     /**
@@ -11784,6 +11979,7 @@ const availableFormatters = {
 /**
  * Get formatter function by name.
  *
+ * @internal
  * @param name - Name of formatter.
  * @returns Formatter function or null if it doesn't exist.
  */