html-validate 6.9.1 → 6.10.0

package/dist/cjs/browser.d.ts

@@ -1,3 +1,2 @@
 export { A as AttributeData, $ as AttributeEvent, f as CSSStyleDeclaration, a1 as ConditionalEvent, C as Config, a as ConfigData, b as ConfigError, c as ConfigLoader, J as ConfigReadyEvent, a4 as DOMLoadEvent, a5 as DOMReadyEvent, t as DeferredMessage, a2 as DirectiveEvent, a3 as DoctypeEvent, D as DynamicValue, _ as ElementReadyEvent, I as Event, G as EventCallback, E as EventDump, F as EventHandler, e as HtmlElement, H as HtmlValidate, a7 as ListenEventMap, L as Location, r as Message, l as MetaCopyableProperty, M as MetaData, j as MetaElement, k as MetaTable, i as NestedError, N as NodeClosed, z as Parser, y as Plugin, P as ProcessElementContext, o as Report, q as Reporter, s as Result, R as Rule, m as RuleDocumentation, h as SchemaValidationError, S as Severity, n as Source, K as SourceReadyEvent, d as StaticConfigLoader, Y as TagCloseEvent, X as TagEndEvent, V as TagOpenEvent, Z as TagReadyEvent, Q as TagStartEvent, x as TemplateExtractor, T as TextNode, g as TokenDump, O as TokenEvent, u as TransformContext, w as Transformer, a6 as TriggerEventMap, U as UserError, a0 as WhitespaceEvent, W as WrappedError, p as configPresets, B as ruleExists, v as version } from './core.js';
 import 'ajv';
-import 'ajv/dist/types';

package/dist/cjs/core.d.ts

@@ -1,5 +1,4 @@
 import { SchemaObject, ErrorObject } from 'ajv';
-import { SchemaObject as SchemaObject$1 } from 'ajv/dist/types';
 
 /** @internal */
 declare type EventCallback = (event: string, data: any) => void;
@@ -1699,7 +1698,7 @@ declare class MetaTable {
     /**
      * @public
      */
-    getJSONSchema(): SchemaObject$1;
+    getJSONSchema(): SchemaObject;
     /**
      * Finds the global element definition and merges each known element with the
      * global, e.g. to assign global attributes.

package/dist/cjs/core.js

@@ -363,6 +363,32 @@ class SchemaValidationError extends UserError {
     }
 }
 
+/**
+ * Computes hash for given string.
+ *
+ * @internal
+ */
+function cyrb53(str) {
+    const a = 2654435761;
+    const b = 1597334677;
+    const c = 2246822507;
+    const d = 3266489909;
+    const e = 4294967296;
+    const f = 2097151;
+    const seed = 0;
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < str.length; i++) {
+        ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, a);
+        h2 = Math.imul(h2 ^ ch, b);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), c) ^ Math.imul(h2 ^ (h2 >>> 13), d);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), c) ^ Math.imul(h1 ^ (h1 >>> 13), d);
+    return e * (f & h2) + (h1 >>> 0);
+}
+const computeHash = cyrb53;
+
 const projectRoot = path__default["default"].resolve(__dirname, "../../");
 			const legacyRequire = require;
 			const distFolder = path__default["default"].resolve(projectRoot, "dist/cjs");
@@ -767,6 +793,35 @@ var schema = {
 	definitions: definitions
 };
 
+/**
+ * AJV keyword "regexp" to validate the type to be a regular expression.
+ * Injects errors with the "type" keyword to give the same output.
+ */
+/* istanbul ignore next: manual testing */
+const ajvRegexpValidate = function (data, dataCxt) {
+    const valid = data instanceof RegExp;
+    if (!valid) {
+        ajvRegexpValidate.errors = [
+            {
+                instancePath: dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
+                schemaPath: undefined,
+                keyword: "type",
+                message: "should be a regular expression",
+                params: {
+                    keyword: "type",
+                },
+            },
+        ];
+    }
+    return valid;
+};
+const ajvRegexpKeyword = {
+    keyword: "regexp",
+    schema: false,
+    errors: true,
+    validate: ajvRegexpValidate,
+};
+
 var TextContent$1;
 (function (TextContent) {
     /* forbid node to have text content, inter-element whitespace is ignored */
@@ -874,6 +929,43 @@ function migrateElement(src) {
     return result;
 }
 
+/**
+ * Returns true if given element is a descendant of given tagname.
+ *
+ * @internal
+ */
+function isDescendant(node, tagName) {
+    let cur = node.parent;
+    while (cur && !cur.isRootElement()) {
+        if (cur.is(tagName)) {
+            return true;
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
+
+/**
+ * Returns true if given element has given attribute (no matter the value, null,
+ * dynamic, etc).
+ */
+function hasAttribute(node, attr) {
+    return node.hasAttribute(attr);
+}
+
+/**
+ * Matches attribute against value.
+ */
+function matchAttribute(node, key, op, value) {
+    const nodeValue = (node.getAttributeValue(key) || "").toLowerCase();
+    switch (op) {
+        case "!=":
+            return nodeValue !== value;
+        case "=":
+            return nodeValue === value;
+    }
+}
+
 const dynamicKeys = [
     "metadata",
     "flow",
@@ -885,44 +977,17 @@ const dynamicKeys = [
     "labelable",
 ];
 const functionTable = {
-    isDescendant,
-    hasAttribute,
-    matchAttribute,
+    isDescendant: isDescendantFacade,
+    hasAttribute: hasAttributeFacade,
+    matchAttribute: matchAttributeFacade,
 };
+const schemaCache = new Map();
 function clone(src) {
     return JSON.parse(JSON.stringify(src));
 }
 function overwriteMerge$1(a, b) {
     return b;
 }
-/**
- * AJV keyword "regexp" to validate the type to be a regular expression.
- * Injects errors with the "type" keyword to give the same output.
- */
-/* istanbul ignore next: manual testing */
-const ajvRegexpValidate = function (data, dataCxt) {
-    const valid = data instanceof RegExp;
-    if (!valid) {
-        ajvRegexpValidate.errors = [
-            {
-                instancePath: dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
-                schemaPath: undefined,
-                keyword: "type",
-                message: "should be regexp",
-                params: {
-                    keyword: "type",
-                },
-            },
-        ];
-    }
-    return valid;
-};
-const ajvRegexpKeyword = {
-    keyword: "regexp",
-    schema: false,
-    errors: true,
-    validate: ajvRegexpValidate,
-};
 /**
  * @public
  */
@@ -1059,11 +1124,20 @@ class MetaTable {
      * Construct a new AJV schema validator.
      */
     getSchemaValidator() {
-        const ajv = new Ajv__default["default"]({ strict: true, strictTuples: true, strictTypes: true });
-        ajv.addMetaSchema(ajvSchemaDraft);
-        ajv.addKeyword(ajvRegexpKeyword);
-        ajv.addKeyword({ keyword: "copyable" });
-        return ajv.compile(this.schema);
+        const hash = computeHash(JSON.stringify(this.schema));
+        const cached = schemaCache.get(hash);
+        if (cached) {
+            return cached;
+        }
+        else {
+            const ajv = new Ajv__default["default"]({ strict: true, strictTuples: true, strictTypes: true });
+            ajv.addMetaSchema(ajvSchemaDraft);
+            ajv.addKeyword(ajvRegexpKeyword);
+            ajv.addKeyword({ keyword: "copyable" });
+            const validate = ajv.compile(this.schema);
+            schemaCache.set(hash, validate);
+            return validate;
+        }
     }
     /**
      * @public
@@ -1165,36 +1239,27 @@ function parseExpression(expr) {
         return [func, options];
     }
 }
-function isDescendant(node, tagName) {
+function isDescendantFacade(node, tagName) {
     if (typeof tagName !== "string") {
         throw new Error(`Property expression "isDescendant" must take string argument when evaluating metadata for <${node.tagName}>`);
     }
-    let cur = node.parent;
-    while (cur && !cur.isRootElement()) {
-        if (cur.is(tagName)) {
-            return true;
-        }
-        cur = cur.parent;
-    }
-    return false;
+    return isDescendant(node, tagName);
 }
-function hasAttribute(node, attr) {
+function hasAttributeFacade(node, attr) {
     if (typeof attr !== "string") {
         throw new Error(`Property expression "hasAttribute" must take string argument when evaluating metadata for <${node.tagName}>`);
     }
-    return node.hasAttribute(attr);
+    return hasAttribute(node, attr);
 }
-function matchAttribute(node, match) {
+function matchAttributeFacade(node, match) {
     if (!Array.isArray(match) || match.length !== 3) {
         throw new Error(`Property expression "matchAttribute" must take [key, op, value] array as argument when evaluating metadata for <${node.tagName}>`);
     }
     const [key, op, value] = match.map((x) => x.toLowerCase());
-    const nodeValue = (node.getAttributeValue(key) || "").toLowerCase();
     switch (op) {
         case "!=":
-            return nodeValue !== value;
         case "=":
-            return nodeValue === value;
+            return matchAttribute(node, key, op, value);
         default:
             throw new Error(`Property expression "matchAttribute" has invalid operator "${op}" when evaluating metadata for <${node.tagName}>`);
     }
@@ -3048,7 +3113,7 @@ var TRANSFORMER_API;
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "6.9.1";
+const version = "6.10.0";
 /** @public */
 const homepage = "https://html-validate.org";
 /** @public */