html-validate 6.0.1 → 6.1.2

package/dist/cjs/core.js

@@ -264,6 +264,9 @@ class NestedError extends Error {
     }
 }
 
+/**
+ * @public
+ */
 class UserError extends NestedError {
 }
 
@@ -274,6 +277,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);
@@ -707,6 +713,8 @@ var TextContent$1;
 /**
  * Properties listed here can be copied (loaded) onto another element using
  * [[HtmlElement.loadMeta]].
+ *
+ * @public
  */
 const MetaCopyableProperty = [
     "metadata",
@@ -847,16 +855,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) {
@@ -877,6 +896,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
      */
@@ -897,6 +917,7 @@ class MetaTable {
     /**
      * Load metadata table from filename
      *
+     * @internal
      * @param filename - Filename to load
      */
     loadFromFile(filename) {
@@ -915,6 +936,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) {
@@ -923,6 +945,8 @@ class MetaTable {
     }
     /**
      * Find all tags which has enabled given property.
+     *
+     * @public
      */
     getTagsWithProperty(propName) {
         return Object.entries(this.elements)
@@ -931,6 +955,8 @@ class MetaTable {
     }
     /**
      * Find tag matching tagName or inheriting from it.
+     *
+     * @public
      */
     getTagsDerivedFrom(tagName) {
         return Object.entries(this.elements)
@@ -962,6 +988,9 @@ class MetaTable {
         ajv.addKeyword({ keyword: "copyable" });
         return ajv.compile(this.schema);
     }
+    /**
+     * @public
+     */
     getJSONSchema() {
         return this.schema;
     }
@@ -997,6 +1026,9 @@ class MetaTable {
         merged.attributes = Object.fromEntries(filteredAttrs);
         return merged;
     }
+    /**
+     * @internal
+     */
     resolve(node) {
         if (node.meta) {
             expandProperties(node, node.meta);
@@ -1091,6 +1123,9 @@ function matchAttribute(node, match) {
     }
 }
 
+/**
+ * @public
+ */
 class DynamicValue {
     constructor(expr) {
         this.expr = expr;
@@ -1741,6 +1776,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 {
     /**
@@ -1772,6 +1809,9 @@ class TextNode extends DOMNode {
     }
 }
 
+/**
+ * @public
+ */
 exports.NodeClosed = void 0;
 (function (NodeClosed) {
     NodeClosed[NodeClosed["Open"] = 0] = "Open";
@@ -1786,6 +1826,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;
@@ -1811,9 +1854,15 @@ class HtmlElement extends DOMNode {
             }
         }
     }
+    /**
+     * @internal
+     */
     static rootNode(location) {
         return new HtmlElement(undefined, null, exports.NodeClosed.EndTag, null, location);
     }
+    /**
+     * @internal
+     */
     static fromTokens(startToken, endToken, parent, metaTable) {
         const tagName = startToken.data[2];
         if (!tagName) {
@@ -2123,6 +2172,8 @@ class HtmlElement extends DOMNode {
     }
     /**
      * Visit all nodes from this node and down. Depth first.
+     *
+     * @internal
      */
     visitDepthFirst(callback) {
         function visit(node) {
@@ -2135,6 +2186,8 @@ class HtmlElement extends DOMNode {
     }
     /**
      * Evaluates callbackk on all descendants, returning true if any are true.
+     *
+     * @internal
      */
     someChildren(callback) {
         return this.childElements.some(visit);
@@ -2149,6 +2202,8 @@ class HtmlElement extends DOMNode {
     }
     /**
      * Evaluates callbackk on all descendants, returning true if all are true.
+     *
+     * @internal
      */
     everyChildren(callback) {
         return this.childElements.every(visit);
@@ -2163,6 +2218,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) {
@@ -2770,6 +2827,9 @@ function compareKey(node, key, filename) {
         }
     }
 }
+/**
+ * @public
+ */
 class TemplateExtractor {
     constructor(ast, filename, data) {
         this.ast = ast;
@@ -2863,19 +2923,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.1";
+/** @public */
+const version = "6.1.2";
+/** @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
+ */
 exports.Severity = void 0;
 (function (Severity) {
     Severity[Severity["DISABLED"] = 0] = "DISABLED";
     Severity[Severity["WARN"] = 1] = "WARN";
     Severity[Severity["ERROR"] = 2] = "ERROR";
 })(exports.Severity || (exports.Severity = {}));
+/**
+ * @internal
+ */
 function parseSeverity(value) {
     switch (value) {
         case 0:
@@ -2923,6 +2992,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 */
@@ -3124,6 +3196,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
@@ -3154,24 +3229,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) {
@@ -3193,16 +3304,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;
             }
         });
@@ -3236,28 +3347,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);
@@ -3341,6 +3473,9 @@ class AriaLabelMisuse extends Rule {
     }
 }
 
+/**
+ * @public
+ */
 class ConfigError extends UserError {
 }
 
@@ -3494,7 +3629,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*)'([^']*?)(')/;
@@ -6159,7 +6294,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;"],
@@ -9459,6 +9594,9 @@ const config = {
     },
 };
 
+/**
+ * @internal
+ */
 const presets = {
     "html-validate:a17y": config$3,
     "html-validate:document": config$2,
@@ -9606,8 +9744,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 = [];
@@ -9670,6 +9813,8 @@ class Config {
      * Validate configuration data.
      *
      * Throws SchemaValidationError if invalid.
+     *
+     * @internal
      */
     static validate(configData, filename = null) {
         var _a;
@@ -9697,6 +9842,8 @@ class Config {
      *
      * Must be called before trying to use config. Can safely be called multiple
      * times.
+     *
+     * @internal
      */
     init() {
         if (this.initialized) {
@@ -9716,6 +9863,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) {
@@ -9808,6 +9956,8 @@ class Config {
     }
     /**
      * Get all configured rules, their severity and options.
+     *
+     * @internal
      */
     getRules() {
         var _a;
@@ -9830,6 +9980,8 @@ class Config {
     }
     /**
      * Get all configured plugins.
+     *
+     * @internal
      */
     getPlugins() {
         return this.plugins;
@@ -9895,6 +10047,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());
@@ -10079,6 +10233,9 @@ class ConfigLoader {
     }
 }
 
+/**
+ * @internal
+ */
 class EventHandler {
     constructor() {
         this.listeners = {};
@@ -10159,6 +10316,8 @@ class ParserError extends Error {
 
 /**
  * Parse HTML document into a DOM tree.
+ *
+ * @internal
  */
 class Parser {
     /**
@@ -10635,6 +10794,9 @@ class Parser {
     }
 }
 
+/**
+ * @internal
+ */
 class Reporter {
     constructor() {
         this.result = {};
@@ -10753,6 +10915,9 @@ function messageSort(a, b) {
     return 0;
 }
 
+/**
+ * @internal
+ */
 class Engine {
     constructor(config, ParserClass) {
         this.report = new Reporter();
@@ -11106,6 +11271,8 @@ class Engine {
  *
  * In practice this means no configuration is fetch by traversing the
  * filesystem.
+ *
+ * @public
  */
 class StaticConfigLoader extends ConfigLoader {
     getConfigFor(handle, configOverride) {
@@ -11145,6 +11312,8 @@ function isConfigData(value) {
  * Primary API for using HTML-validate.
  *
  * Provides high-level abstractions for common operations.
+ *
+ * @public
  */
 class HtmlValidate {
     constructor(arg) {
@@ -11349,6 +11518,7 @@ class HtmlValidate {
     /**
      * Create a parser configured for given filename.
      *
+     * @internal
      * @param source - Source to use.
      */
     getParserFor(source) {
@@ -11392,6 +11562,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
@@ -11420,6 +11591,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
  */
@@ -11459,6 +11631,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 {
     /**
@@ -11796,6 +11970,7 @@ const availableFormatters = {
 /**
  * Get formatter function by name.
  *
+ * @internal
  * @param name - Name of formatter.
  * @returns Formatter function or null if it doesn't exist.
  */