html-validate 7.5.0 → 7.7.0

package/dist/es/core.d.ts

@@ -1001,731 +1001,774 @@ interface CSSStyleDeclaration {
     [key: string]: string;
 }
 
-interface PermittedGroup {
-    exclude?: string | string[];
-}
-declare type CategoryOrTag = string;
-declare type PropertyExpression = string | [string, any];
-declare type PermittedEntry = CategoryOrTag | PermittedGroup | Array<CategoryOrTag | PermittedGroup>;
-declare type Permitted = PermittedEntry[];
-declare type PermittedOrder = string[];
-declare type RequiredAncestors = string[];
-declare type RequiredContent = string[];
-declare enum TextContent {
-    NONE = "none",
-    DEFAULT = "default",
-    REQUIRED = "required",
-    ACCESSIBLE = "accessible"
-}
 /**
  * @public
  */
-interface MetaAttribute {
-    boolean?: boolean;
-    deprecated?: boolean | string;
-    enum?: Array<string | RegExp>;
-    list?: boolean;
-    omit?: boolean;
-    required?: boolean;
+interface TransformContext {
+    /**
+     * Test if an additional chainable transformer is present.
+     *
+     * Returns true only if there is a transformer configured for the given
+     * filename.
+     *
+     * @param filename - Filename to use to match next transformer.
+     */
+    hasChain(filename: string): boolean;
+    /**
+     * Chain transformations.
+     *
+     * Sometimes multiple transformers must be applied. For instance, a Markdown
+     * file with JSX in a code-block.
+     *
+     * @param source - Source to chain transformations on.
+     * @param filename - Filename to use to match next transformer (unrelated to
+     * filename set in source)
+     */
+    chain(source: Source, filename: string): Iterable<Source>;
 }
-declare type PermittedAttribute = Record<string, MetaAttribute | Array<string | RegExp> | null>;
-interface DeprecatedElement {
-    message?: string;
-    documentation?: string;
-    source?: string;
+
+declare module "estree" {
+    interface TemplateElement {
+        start: number;
+        end: number;
+    }
 }
 /**
  * @public
  */
-interface MetaData {
-    inherit?: string;
-    metadata?: boolean | PropertyExpression;
-    flow?: boolean | PropertyExpression;
-    sectioning?: boolean | PropertyExpression;
-    heading?: boolean | PropertyExpression;
-    phrasing?: boolean | PropertyExpression;
-    embedded?: boolean | PropertyExpression;
-    interactive?: boolean | PropertyExpression;
-    deprecated?: boolean | string | DeprecatedElement;
-    foreign?: boolean;
-    void?: boolean;
-    transparent?: boolean | string[];
-    implicitClosed?: string[];
-    scriptSupporting?: boolean;
-    form?: boolean;
-    labelable?: boolean | PropertyExpression;
-    deprecatedAttributes?: string[];
-    requiredAttributes?: string[];
-    attributes?: PermittedAttribute;
-    permittedContent?: Permitted;
-    permittedDescendants?: Permitted;
-    permittedOrder?: PermittedOrder;
-    permittedParent?: Permitted;
-    requiredAncestors?: RequiredAncestors;
-    requiredContent?: RequiredContent;
-    textContent?: TextContent;
+declare class TemplateExtractor {
+    private ast;
+    private filename;
+    private data;
+    private constructor();
+    static fromFilename(filename: string): TemplateExtractor;
+    /**
+     * Create a new [[TemplateExtractor]] from javascript source code.
+     *
+     * `Source` offsets will be relative to the string, i.e. offset 0 is the first
+     * character of the string. If the string is only a subset of a larger string
+     * the offsets must be adjusted manually.
+     *
+     * @param source - Source code.
+     * @param filename - Optional filename to set in the resulting
+     * `Source`. Defauls to `"inline"`.
+     */
+    static fromString(source: string, filename?: string): TemplateExtractor;
+    /**
+     * Convenience function to create a [[Source]] instance from an existing file.
+     *
+     * @param filename - Filename with javascript source code. The file must exist
+     * and be readable by the user.
+     * @returns An array of Source's suitable for passing to [[Engine]] linting
+     * functions.
+     */
+    static createSource(filename: string): Source[];
+    /**
+     * Extract object properties.
+     *
+     * Given a key `"template"` this method finds all objects literals with a
+     * `"template"` property and creates a [[Source]] instance with proper offsets
+     * with the value of the property. For instance:
+     *
+     * ```
+     * const myObj = {
+     *   foo: 'bar',
+     * };
+     * ```
+     *
+     * The above snippet would yield a `Source` with the content `bar`.
+     *
+     */
+    extractObjectProperty(key: string): Source[];
 }
+
 /**
- * Properties listed here can be used to reverse search elements with the given
- * property enabled. See [[MetaTable.getTagsWithProperty]].
- */
-declare type MetaLookupableProperty = "metadata" | "flow" | "sectioning" | "heading" | "phrasing" | "embedded" | "interactive" | "deprecated" | "foreign" | "void" | "transparent" | "scriptSupporting" | "form" | "labelable";
-/**
- * Properties listed here can be copied (loaded) onto another element using
- * [[HtmlElement.loadMeta]].
- *
  * @public
  */
-declare const MetaCopyableProperty: Array<keyof MetaElement>;
+declare type Transformer = (this: TransformContext, source: Source) => Iterable<Source>;
+
+interface SchemaValidationPatch {
+    properties?: Record<string, unknown>;
+    definitions?: Record<string, unknown>;
+}
 /**
  * @public
  */
-interface MetaElement extends Omit<MetaData, "deprecatedAttributes" | "requiredAttributes"> {
-    tagName: string;
-    attributes: Record<string, MetaAttribute>;
-}
-interface MetaDataTable {
-    [tagName: string]: MetaData;
-}
-interface ElementTable {
-    [tagName: string]: MetaElement;
-}
-
-declare enum NodeType {
-    ELEMENT_NODE = 1,
-    TEXT_NODE = 3,
-    DOCUMENT_NODE = 9
-}
-
-interface DOMNodeCache {
-}
-
-declare type DOMInternalID = number;
-declare const TEXT_CONTENT: unique symbol;
-declare module "./cache" {
-    interface DOMNodeCache {
-        [TEXT_CONTENT]: string;
-    }
-}
-declare class DOMNode {
-    readonly nodeName: string;
-    readonly nodeType: NodeType;
-    readonly childNodes: DOMNode[];
-    readonly location: Location;
-    readonly unique: DOMInternalID;
-    private cache;
+interface Plugin {
     /**
-     * Set of disabled rules for this node.
+     * Name of the plugin.
      *
-     * Rules disabled by using directives are added here.
-     */
-    private disabledRules;
-    /**
-     * Create a new DOMNode.
+     * If specified this is the name used when referring to the plugin. Default is
+     * to use the name/path the user used when loading the plugin. To be less
+     * confusing for users you should use the same name as your package.
      *
-     * @param nodeType - What node type to create.
-     * @param nodeName - What node name to use. For `HtmlElement` this corresponds
-     * to the tagName but other node types have specific predefined values.
-     * @param location - Source code location of this node.
+     * The name must be a valid package name according to NPM (basically lowercase
+     * characters, must not begin with dot, slash or non-url safe characters).
+     *
+     * Hint: import and use the name from `package.json`.
      */
-    constructor(nodeType: NodeType, nodeName: string | undefined, location: Location);
+    name?: string | null;
     /**
-     * Enable cache for this node.
+     * Initialization callback.
      *
-     * Should not be called before the node and all children are fully constructed.
+     * Called once per plugin during initialization.
      */
-    cacheEnable(): void;
+    init?: () => void | null;
     /**
-     * Fetch cached value from this DOM node.
+     * Setup callback.
      *
-     * Cache is not enabled until `cacheEnable()` is called by [[Parser]] (when
-     * the element is fully constructed).
+     * Called once per source after engine is initialized.
      *
-     * @returns value or `undefined` if the value doesn't exist.
+     * @param source - The source about to be validated. Readonly.
+     * @param eventhandler - Eventhandler from parser. Can be used to listen for
+     * parser events.
      */
-    cacheGet<K extends keyof DOMNodeCache>(key: K): DOMNodeCache[K] | undefined;
-    cacheGet(key: string | number | symbol): any | undefined;
+    setup?: (source: Source, eventhandler: EventHandler) => void | null;
     /**
-     * Store a value in cache.
+     * Configuration presets.
      *
-     * @returns the value itself is returned.
-     */
-    cacheSet<K extends keyof DOMNodeCache>(key: K, value: DOMNodeCache[K]): DOMNodeCache[K];
-    cacheSet<T>(key: string | number | symbol, value: T): T;
-    /**
-     * Remove a value by key from cache.
+     * Each key should be the unprefixed name which a configuration later can
+     * access using `${plugin}:${key}`, e.g. if a plugin named "my-plugin" exposes
+     * a preset named "foobar" it can be accessed using:
      *
-     * @returns `true` if the entry existed and has been removed.
-     */
-    cacheRemove<K extends keyof DOMNodeCache>(key: K): boolean;
-    cacheRemove(key: string | number | symbol): boolean;
-    /**
-     * Check if key exists in cache.
-     */
-    cacheExists<K extends keyof DOMNodeCache>(key: K): boolean;
-    cacheExists(key: string | number | symbol): boolean;
-    /**
-     * Get the text (recursive) from all child nodes.
-     */
-    get textContent(): string;
-    append(node: DOMNode): void;
-    isRootElement(): boolean;
-    /**
-     * Tests if two nodes are the same (references the same object).
-     */
-    isSameNode(otherNode: DOMNode): boolean;
-    /**
-     * Returns a DOMNode representing the first direct child node or `null` if the
-     * node has no children.
-     */
-    get firstChild(): DOMNode;
-    /**
-     * Returns a DOMNode representing the last direct child node or `null` if the
-     * node has no children.
-     */
-    get lastChild(): DOMNode;
-    /**
-     * Disable a rule for this node.
-     */
-    disableRule(ruleId: string): void;
-    /**
-     * Disables multiple rules.
+     * "extends": ["my-plugin:foobar"]
      */
-    disableRules(rules: string[]): void;
+    configs?: Record<string, ConfigData | null> | null;
     /**
-     * Enable a previously disabled rule for this node.
+     * List of new rules present.
      */
-    enableRule(ruleId: string): void;
+    rules?: Record<string, RuleConstructor<any, any> | null> | null;
     /**
-     * Enables multiple rules.
+     * Transformer available in this plugin.
+     *
+     * Can be given either as a single unnamed transformer or an object with
+     * multiple named.
+     *
+     * Unnamed transformers use the plugin name similar to how a standalone
+     * transformer would work:
+     *
+     * ```
+     * "transform": {
+     *   "^.*\\.foo$": "my-plugin"
+     * }
+     * ```
+     *
+     * For named transformers each key should be the unprefixed name which a
+     * configuration later can access using `${plugin}:${key}`, e.g. if a plugin
+     * named "my-plugin" exposes a transformer named "foobar" it can be accessed
+     * using:
+     *
+     * ```
+     * "transform": {
+     *   "^.*\\.foo$": "my-plugin:foobar"
+     * }
+     * ```
      */
-    enableRules(rules: string[]): void;
+    transformer?: Transformer | Record<string, Transformer | null> | null;
     /**
-     * Test if a rule is enabled for this node.
+     * Extend metadata validation schema.
      */
-    ruleEnabled(ruleId: string): boolean;
-    generateSelector(): string | null;
-}
-
-declare class DOMTokenList extends Array<string> {
-    readonly value: string;
-    private readonly locations;
-    constructor(value: string | DynamicValue | null, location: Location | null);
-    item(n: number): string | undefined;
-    location(n: number): Location | undefined;
-    contains(token: string): boolean;
-    iterator(): Generator<{
-        index: number;
-        item: string;
-        location: Location;
-    }>;
+    elementSchema?: SchemaValidationPatch | null;
 }
 
 /**
  * @public
  */
-declare enum NodeClosed {
-    Open = 0,
-    EndTag = 1,
-    VoidOmitted = 2,
-    VoidSelfClosed = 3,
-    ImplicitClosed = 4
-}
-/**
- * @public
- */
-declare class HtmlElement extends DOMNode {
-    readonly tagName: string;
-    readonly parent: HtmlElement | null;
-    readonly voidElement: boolean;
-    readonly depth: number;
-    closed: NodeClosed;
-    protected readonly attr: {
-        [key: string]: Attribute[];
-    };
-    private metaElement;
-    private annotation;
-    constructor(tagName: string | undefined, parent: HtmlElement | null, closed: NodeClosed, meta: MetaElement | null, location: Location);
+declare class MetaTable {
+    readonly elements: ElementTable;
+    private schema;
     /**
      * @internal
      */
-    static rootNode(location: Location): HtmlElement;
+    constructor();
     /**
      * @internal
-     *
-     * @param namespace - If given it is appended to the tagName.
      */
-    static fromTokens(startToken: TagOpenToken, endToken: TagCloseToken, parent: HtmlElement | null, metaTable: MetaTable | null, namespace?: string): HtmlElement;
+    init(): void;
     /**
-     * Returns annotated name if set or defaults to `<tagName>`.
+     * Extend validation schema.
      *
-     * E.g. `my-annotation` or `<div>`.
-     */
-    get annotatedName(): string;
-    /**
-     * Similar to childNodes but only elements.
+     * @internal
      */
-    get childElements(): HtmlElement[];
+    extendValidationSchema(patch: SchemaValidationPatch): void;
     /**
-     * Find the first ancestor matching a selector.
+     * Load metadata table from object.
      *
-     * Implementation of DOM specification of Element.closest(selectors).
+     * @internal
+     * @param obj - Object with metadata to load
+     * @param filename - Optional filename used when presenting validation error
      */
-    closest(selectors: string): HtmlElement | null;
+    loadFromObject(obj: unknown, filename?: string | null): void;
     /**
-     * Generate a DOM selector for this element. The returned selector will be
-     * unique inside the current document.
+     * Load metadata table from filename
+     *
+     * @internal
+     * @param filename - Filename to load
      */
-    generateSelector(): string | null;
+    loadFromFile(filename: string): void;
     /**
-     * Tests if this element has given tagname.
+     * Get [[MetaElement]] for the given tag. If no specific metadata is present
+     * the global metadata is returned or null if no global is present.
      *
-     * If passing "*" this test will pass if any tagname is set.
+     * @public
+     * @returns A shallow copy of metadata.
      */
-    is(tagName: string): boolean;
+    getMetaFor(tagName: string): MetaElement | null;
     /**
-     * Load new element metadata onto this element.
-     *
-     * Do note that semantics such as `void` cannot be changed (as the element has
-     * already been created). In addition the element will still "be" the same
-     * element, i.e. even if loading meta for a `<p>` tag upon a `<div>` tag it
-     * will still be a `<div>` as far as the rest of the validator is concerned.
-     *
-     * In fact only certain properties will be copied onto the element:
-     *
-     * - content categories (flow, phrasing, etc)
-     * - required attributes
-     * - attribute allowed values
-     * - permitted/required elements
-     *
-     * Properties *not* loaded:
-     *
-     * - inherit
-     * - deprecated
-     * - foreign
-     * - void
-     * - implicitClosed
-     * - scriptSupporting
-     * - deprecatedAttributes
+     * Find all tags which has enabled given property.
      *
-     * Changes to element metadata will only be visible after `element:ready` (and
-     * the subsequent `dom:ready` event).
+     * @public
      */
-    loadMeta(meta: MetaElement): void;
+    getTagsWithProperty(propName: MetaLookupableProperty): string[];
     /**
-     * Match this element against given selectors. Returns true if any selector
-     * matches.
+     * Find tag matching tagName or inheriting from it.
      *
-     * Implementation of DOM specification of Element.matches(selectors).
+     * @public
      */
-    matches(selector: string): boolean;
-    get meta(): MetaElement | null;
+    getTagsDerivedFrom(tagName: string): string[];
+    private addEntry;
     /**
-     * Set annotation for this element.
+     * Construct a new AJV schema validator.
      */
-    setAnnotation(text: string): void;
+    private getSchemaValidator;
     /**
-     * Set attribute. Stores all attributes set even with the same name.
-     *
-     * @param key - Attribute name
-     * @param value - Attribute value. Use `null` if no value is present.
-     * @param keyLocation - Location of the attribute name.
-     * @param valueLocation - Location of the attribute value (excluding quotation)
-     * @param originalAttribute - If attribute is an alias for another attribute
-     * (dynamic attributes) set this to the original attribute name.
+     * @public
      */
-    setAttribute(key: string, value: string | DynamicValue | null, keyLocation: Location, valueLocation: Location | null, originalAttribute?: string): void;
+    getJSONSchema(): SchemaObject;
     /**
-     * Get a list of all attributes on this node.
+     * Finds the global element definition and merges each known element with the
+     * global, e.g. to assign global attributes.
      */
-    get attributes(): Attribute[];
-    hasAttribute(key: string): boolean;
+    private resolveGlobal;
+    private mergeElement;
     /**
-     * Get attribute.
-     *
-     * By default only the first attribute is returned but if the code needs to
-     * handle duplicate attributes the `all` parameter can be set to get all
-     * attributes with given key.
-     *
-     * This usually only happens when code contains duplicate attributes (which
-     * `no-dup-attr` will complain about) or when a static attribute is combined
-     * with a dynamic, consider:
-     *
-     * <p class="foo" dynamic-class="bar">
-     *
-     * @param key - Attribute name
-     * @param all - Return single or all attributes.
+     * @internal
      */
-    getAttribute(key: string): Attribute | null;
-    getAttribute(key: string, all: true): Attribute[];
+    resolve(node: HtmlElement): void;
+}
+
+declare enum NodeType {
+    ELEMENT_NODE = 1,
+    TEXT_NODE = 3,
+    DOCUMENT_NODE = 9
+}
+
+interface DOMNodeCache {
+}
+
+declare type DOMInternalID = number;
+declare const TEXT_CONTENT: unique symbol;
+declare module "./cache" {
+    interface DOMNodeCache {
+        [TEXT_CONTENT]: string;
+    }
+}
+declare class DOMNode {
+    readonly nodeName: string;
+    readonly nodeType: NodeType;
+    readonly childNodes: DOMNode[];
+    readonly location: Location;
+    readonly unique: DOMInternalID;
+    private cache;
     /**
-     * Get attribute value.
-     *
-     * Returns the attribute value if present.
-     *
-     * - Missing attributes return `null`.
-     * - Boolean attributes return `null`.
-     * - `DynamicValue` returns attribute expression.
+     * Set of disabled rules for this node.
      *
-     * @param key - Attribute name
-     * @returns Attribute value or null.
+     * Rules disabled by using directives are added here.
      */
-    getAttributeValue(key: string): string | null;
+    private disabledRules;
     /**
-     * Add text as a child node to this element.
+     * Create a new DOMNode.
      *
-     * @param text - Text to add.
-     * @param location - Source code location of this text.
+     * @param nodeType - What node type to create.
+     * @param nodeName - What node name to use. For `HtmlElement` this corresponds
+     * to the tagName but other node types have specific predefined values.
+     * @param location - Source code location of this node.
      */
-    appendText(text: string | DynamicValue, location: Location): void;
+    constructor(nodeType: NodeType, nodeName: string | undefined, location: Location);
     /**
-     * Return a list of all known classes on the element. Dynamic values are
-     * ignored.
+     * Enable cache for this node.
+     *
+     * Should not be called before the node and all children are fully constructed.
      */
-    get classList(): DOMTokenList;
+    cacheEnable(): void;
     /**
-     * Get element ID if present.
+     * Fetch cached value from this DOM node.
+     *
+     * Cache is not enabled until `cacheEnable()` is called by [[Parser]] (when
+     * the element is fully constructed).
+     *
+     * @returns value or `undefined` if the value doesn't exist.
      */
-    get id(): string | null;
-    get style(): CSSStyleDeclaration;
+    cacheGet<K extends keyof DOMNodeCache>(key: K): DOMNodeCache[K] | undefined;
+    cacheGet(key: string | number | symbol): any | undefined;
     /**
-     * Returns the first child element or null if there are no child elements.
+     * Store a value in cache.
+     *
+     * @returns the value itself is returned.
      */
-    get firstElementChild(): HtmlElement | null;
+    cacheSet<K extends keyof DOMNodeCache>(key: K, value: DOMNodeCache[K]): DOMNodeCache[K];
+    cacheSet<T>(key: string | number | symbol, value: T): T;
     /**
-     * Returns the last child element or null if there are no child elements.
+     * Remove a value by key from cache.
+     *
+     * @returns `true` if the entry existed and has been removed.
      */
-    get lastElementChild(): HtmlElement | null;
-    get siblings(): HtmlElement[];
-    get previousSibling(): HtmlElement | null;
-    get nextSibling(): HtmlElement | null;
-    getElementsByTagName(tagName: string): HtmlElement[];
-    querySelector(selector: string): HtmlElement;
-    querySelectorAll(selector: string): HtmlElement[];
-    private querySelectorImpl;
+    cacheRemove<K extends keyof DOMNodeCache>(key: K): boolean;
+    cacheRemove(key: string | number | symbol): boolean;
     /**
-     * Visit all nodes from this node and down. Depth first.
-     *
-     * @internal
+     * Check if key exists in cache.
      */
-    visitDepthFirst(callback: (node: HtmlElement) => void): void;
+    cacheExists<K extends keyof DOMNodeCache>(key: K): boolean;
+    cacheExists(key: string | number | symbol): boolean;
     /**
-     * Evaluates callbackk on all descendants, returning true if any are true.
-     *
-     * @internal
+     * Get the text (recursive) from all child nodes.
      */
-    someChildren(callback: (node: HtmlElement) => boolean): boolean;
+    get textContent(): string;
+    append(node: DOMNode): void;
+    isRootElement(): boolean;
     /**
-     * Evaluates callbackk on all descendants, returning true if all are true.
-     *
-     * @internal
+     * Tests if two nodes are the same (references the same object).
      */
-    everyChildren(callback: (node: HtmlElement) => boolean): boolean;
+    isSameNode(otherNode: DOMNode): boolean;
     /**
-     * Visit all nodes from this node and down. Breadth first.
-     *
-     * The first node for which the callback evaluates to true is returned.
-     *
-     * @internal
+     * Returns a DOMNode representing the first direct child node or `null` if the
+     * node has no children.
      */
-    find(callback: (node: HtmlElement) => boolean): HtmlElement | null;
-}
-
-declare class DOMTree {
-    readonly root: HtmlElement;
-    private active;
-    doctype: string | null;
-    constructor(location: Location);
-    pushActive(node: HtmlElement): void;
-    popActive(): void;
-    getActive(): HtmlElement;
+    get firstChild(): DOMNode;
     /**
-     * Resolve dynamic meta expressions.
+     * Returns a DOMNode representing the last direct child node or `null` if the
+     * node has no children.
      */
-    resolveMeta(table: MetaTable): void;
-    getElementsByTagName(tagName: string): HtmlElement[];
-    visitDepthFirst(callback: (node: HtmlElement) => void): void;
-    find(callback: (node: HtmlElement) => boolean): HtmlElement | null;
-    querySelector(selector: string): HtmlElement;
-    querySelectorAll(selector: string): HtmlElement[];
-}
-
-/**
- * Represents a text in the HTML document.
- *
- * Text nodes are appended as children of `HtmlElement` and cannot have childen
- * of its own.
- *
- * @public
- */
-declare class TextNode extends DOMNode {
-    private readonly text;
+    get lastChild(): DOMNode;
     /**
-     * @param text - Text to add. When a `DynamicValue` is used the expression is
-     * used as "text".
-     * @param location - Source code location of this node.
+     * Disable a rule for this node.
+     */
+    disableRule(ruleId: string): void;
+    /**
+     * Disables multiple rules.
      */
-    constructor(text: string | DynamicValue, location: Location);
+    disableRules(rules: string[]): void;
     /**
-     * Get the text from node.
+     * Enable a previously disabled rule for this node.
      */
-    get textContent(): string;
+    enableRule(ruleId: string): void;
     /**
-     * Flag set to true if the attribute value is static.
+     * Enables multiple rules.
      */
-    get isStatic(): boolean;
+    enableRules(rules: string[]): void;
     /**
-     * Flag set to true if the attribute value is dynamic.
+     * Test if a rule is enabled for this node.
      */
-    get isDynamic(): boolean;
+    ruleEnabled(ruleId: string): boolean;
+    generateSelector(): string | null;
+}
+
+declare class DOMTokenList extends Array<string> {
+    readonly value: string;
+    private readonly locations;
+    constructor(value: string | DynamicValue | null, location: Location | null);
+    item(n: number): string | undefined;
+    location(n: number): Location | undefined;
+    contains(token: string): boolean;
+    iterator(): Generator<{
+        index: number;
+        item: string;
+        location: Location;
+    }>;
 }
 
 /**
  * @public
  */
-interface TransformContext {
+declare enum NodeClosed {
+    Open = 0,
+    EndTag = 1,
+    VoidOmitted = 2,
+    VoidSelfClosed = 3,
+    ImplicitClosed = 4
+}
+/**
+ * @public
+ */
+declare class HtmlElement extends DOMNode {
+    readonly tagName: string;
+    readonly parent: HtmlElement | null;
+    readonly voidElement: boolean;
+    readonly depth: number;
+    closed: NodeClosed;
+    protected readonly attr: {
+        [key: string]: Attribute[];
+    };
+    private metaElement;
+    private annotation;
+    constructor(tagName: string | undefined, parent: HtmlElement | null, closed: NodeClosed, meta: MetaElement | null, location: Location);
     /**
-     * Test if an additional chainable transformer is present.
-     *
-     * Returns true only if there is a transformer configured for the given
-     * filename.
-     *
-     * @param filename - Filename to use to match next transformer.
+     * @internal
      */
-    hasChain(filename: string): boolean;
+    static rootNode(location: Location): HtmlElement;
     /**
-     * Chain transformations.
+     * @internal
      *
-     * Sometimes multiple transformers must be applied. For instance, a Markdown
-     * file with JSX in a code-block.
+     * @param namespace - If given it is appended to the tagName.
+     */
+    static fromTokens(startToken: TagOpenToken, endToken: TagCloseToken, parent: HtmlElement | null, metaTable: MetaTable | null, namespace?: string): HtmlElement;
+    /**
+     * Returns annotated name if set or defaults to `<tagName>`.
      *
-     * @param source - Source to chain transformations on.
-     * @param filename - Filename to use to match next transformer (unrelated to
-     * filename set in source)
+     * E.g. `my-annotation` or `<div>`.
      */
-    chain(source: Source, filename: string): Iterable<Source>;
-}
-
-declare module "estree" {
-    interface TemplateElement {
-        start: number;
-        end: number;
-    }
-}
-/**
- * @public
- */
-declare class TemplateExtractor {
-    private ast;
-    private filename;
-    private data;
-    private constructor();
-    static fromFilename(filename: string): TemplateExtractor;
+    get annotatedName(): string;
     /**
-     * Create a new [[TemplateExtractor]] from javascript source code.
+     * Get list of IDs referenced by `aria-labelledby`.
      *
-     * `Source` offsets will be relative to the string, i.e. offset 0 is the first
-     * character of the string. If the string is only a subset of a larger string
-     * the offsets must be adjusted manually.
+     * If the attribute is unset or empty this getter returns null.
+     * If the attribute is dynamic the original {@link DynamicValue} is returned.
      *
-     * @param source - Source code.
-     * @param filename - Optional filename to set in the resulting
-     * `Source`. Defauls to `"inline"`.
+     * @public
      */
-    static fromString(source: string, filename?: string): TemplateExtractor;
+    get ariaLabelledby(): string[] | DynamicValue | null;
     /**
-     * Convenience function to create a [[Source]] instance from an existing file.
+     * Similar to childNodes but only elements.
+     */
+    get childElements(): HtmlElement[];
+    /**
+     * Find the first ancestor matching a selector.
      *
-     * @param filename - Filename with javascript source code. The file must exist
-     * and be readable by the user.
-     * @returns An array of Source's suitable for passing to [[Engine]] linting
-     * functions.
+     * Implementation of DOM specification of Element.closest(selectors).
      */
-    static createSource(filename: string): Source[];
+    closest(selectors: string): HtmlElement | null;
     /**
-     * Extract object properties.
+     * Generate a DOM selector for this element. The returned selector will be
+     * unique inside the current document.
+     */
+    generateSelector(): string | null;
+    /**
+     * Tests if this element has given tagname.
      *
-     * Given a key `"template"` this method finds all objects literals with a
-     * `"template"` property and creates a [[Source]] instance with proper offsets
-     * with the value of the property. For instance:
+     * If passing "*" this test will pass if any tagname is set.
+     */
+    is(tagName: string): boolean;
+    /**
+     * Load new element metadata onto this element.
      *
-     * ```
-     * const myObj = {
-     *   foo: 'bar',
-     * };
-     * ```
+     * Do note that semantics such as `void` cannot be changed (as the element has
+     * already been created). In addition the element will still "be" the same
+     * element, i.e. even if loading meta for a `<p>` tag upon a `<div>` tag it
+     * will still be a `<div>` as far as the rest of the validator is concerned.
      *
-     * The above snippet would yield a `Source` with the content `bar`.
+     * In fact only certain properties will be copied onto the element:
      *
-     */
-    extractObjectProperty(key: string): Source[];
-}
-
-/**
- * @public
- */
-declare type Transformer = (this: TransformContext, source: Source) => Iterable<Source>;
-
-interface SchemaValidationPatch {
-    properties?: Record<string, unknown>;
-    definitions?: Record<string, unknown>;
-}
-/**
- * @public
- */
-interface Plugin {
-    /**
-     * Name of the plugin.
+     * - content categories (flow, phrasing, etc)
+     * - required attributes
+     * - attribute allowed values
+     * - permitted/required elements
      *
-     * If specified this is the name used when referring to the plugin. Default is
-     * to use the name/path the user used when loading the plugin. To be less
-     * confusing for users you should use the same name as your package.
+     * Properties *not* loaded:
      *
-     * The name must be a valid package name according to NPM (basically lowercase
-     * characters, must not begin with dot, slash or non-url safe characters).
+     * - inherit
+     * - deprecated
+     * - foreign
+     * - void
+     * - implicitClosed
+     * - scriptSupporting
+     * - deprecatedAttributes
      *
-     * Hint: import and use the name from `package.json`.
+     * Changes to element metadata will only be visible after `element:ready` (and
+     * the subsequent `dom:ready` event).
      */
-    name?: string | null;
+    loadMeta(meta: MetaElement): void;
     /**
-     * Initialization callback.
+     * Match this element against given selectors. Returns true if any selector
+     * matches.
      *
-     * Called once per plugin during initialization.
+     * Implementation of DOM specification of Element.matches(selectors).
      */
-    init?: () => void | null;
+    matches(selector: string): boolean;
+    get meta(): MetaElement | null;
     /**
-     * Setup callback.
-     *
-     * Called once per source after engine is initialized.
-     *
-     * @param source - The source about to be validated. Readonly.
-     * @param eventhandler - Eventhandler from parser. Can be used to listen for
-     * parser events.
+     * Set annotation for this element.
      */
-    setup?: (source: Source, eventhandler: EventHandler) => void | null;
+    setAnnotation(text: string): void;
     /**
-     * Configuration presets.
-     *
-     * Each key should be the unprefixed name which a configuration later can
-     * access using `${plugin}:${key}`, e.g. if a plugin named "my-plugin" exposes
-     * a preset named "foobar" it can be accessed using:
+     * Set attribute. Stores all attributes set even with the same name.
      *
-     * "extends": ["my-plugin:foobar"]
+     * @param key - Attribute name
+     * @param value - Attribute value. Use `null` if no value is present.
+     * @param keyLocation - Location of the attribute name.
+     * @param valueLocation - Location of the attribute value (excluding quotation)
+     * @param originalAttribute - If attribute is an alias for another attribute
+     * (dynamic attributes) set this to the original attribute name.
      */
-    configs?: Record<string, ConfigData | null> | null;
+    setAttribute(key: string, value: string | DynamicValue | null, keyLocation: Location, valueLocation: Location | null, originalAttribute?: string): void;
     /**
-     * List of new rules present.
+     * Get a list of all attributes on this node.
      */
-    rules?: Record<string, RuleConstructor<any, any> | null> | null;
+    get attributes(): Attribute[];
+    hasAttribute(key: string): boolean;
     /**
-     * Transformer available in this plugin.
+     * Get attribute.
      *
-     * Can be given either as a single unnamed transformer or an object with
-     * multiple named.
+     * By default only the first attribute is returned but if the code needs to
+     * handle duplicate attributes the `all` parameter can be set to get all
+     * attributes with given key.
      *
-     * Unnamed transformers use the plugin name similar to how a standalone
-     * transformer would work:
+     * This usually only happens when code contains duplicate attributes (which
+     * `no-dup-attr` will complain about) or when a static attribute is combined
+     * with a dynamic, consider:
      *
-     * ```
-     * "transform": {
-     *   "^.*\\.foo$": "my-plugin"
-     * }
-     * ```
+     * <p class="foo" dynamic-class="bar">
      *
-     * For named transformers each key should be the unprefixed name which a
-     * configuration later can access using `${plugin}:${key}`, e.g. if a plugin
-     * named "my-plugin" exposes a transformer named "foobar" it can be accessed
-     * using:
+     * @param key - Attribute name
+     * @param all - Return single or all attributes.
+     */
+    getAttribute(key: string): Attribute | null;
+    getAttribute(key: string, all: true): Attribute[];
+    /**
+     * Get attribute value.
+     *
+     * Returns the attribute value if present.
+     *
+     * - Missing attributes return `null`.
+     * - Boolean attributes return `null`.
+     * - `DynamicValue` returns attribute expression.
      *
-     * ```
-     * "transform": {
-     *   "^.*\\.foo$": "my-plugin:foobar"
-     * }
-     * ```
+     * @param key - Attribute name
+     * @returns Attribute value or null.
      */
-    transformer?: Transformer | Record<string, Transformer | null> | null;
+    getAttributeValue(key: string): string | null;
     /**
-     * Extend metadata validation schema.
+     * Add text as a child node to this element.
+     *
+     * @param text - Text to add.
+     * @param location - Source code location of this text.
      */
-    elementSchema?: SchemaValidationPatch | null;
-}
-
-/**
- * @public
- */
-declare class MetaTable {
-    readonly elements: ElementTable;
-    private schema;
+    appendText(text: string | DynamicValue, location: Location): void;
     /**
-     * @internal
+     * Return a list of all known classes on the element. Dynamic values are
+     * ignored.
      */
-    constructor();
+    get classList(): DOMTokenList;
     /**
-     * @internal
+     * Get element ID if present.
      */
-    init(): void;
+    get id(): string | null;
+    get style(): CSSStyleDeclaration;
     /**
-     * Extend validation schema.
-     *
-     * @internal
+     * Returns the first child element or null if there are no child elements.
      */
-    extendValidationSchema(patch: SchemaValidationPatch): void;
+    get firstElementChild(): HtmlElement | null;
     /**
-     * Load metadata table from object.
+     * Returns the last child element or null if there are no child elements.
+     */
+    get lastElementChild(): HtmlElement | null;
+    get siblings(): HtmlElement[];
+    get previousSibling(): HtmlElement | null;
+    get nextSibling(): HtmlElement | null;
+    getElementsByTagName(tagName: string): HtmlElement[];
+    querySelector(selector: string): HtmlElement;
+    querySelectorAll(selector: string): HtmlElement[];
+    private querySelectorImpl;
+    /**
+     * Visit all nodes from this node and down. Depth first.
      *
      * @internal
-     * @param obj - Object with metadata to load
-     * @param filename - Optional filename used when presenting validation error
      */
-    loadFromObject(obj: unknown, filename?: string | null): void;
+    visitDepthFirst(callback: (node: HtmlElement) => void): void;
     /**
-     * Load metadata table from filename
+     * Evaluates callbackk on all descendants, returning true if any are true.
      *
      * @internal
-     * @param filename - Filename to load
      */
-    loadFromFile(filename: string): void;
+    someChildren(callback: (node: HtmlElement) => boolean): boolean;
     /**
-     * Get [[MetaElement]] for the given tag. If no specific metadata is present
-     * the global metadata is returned or null if no global is present.
+     * Evaluates callbackk on all descendants, returning true if all are true.
      *
-     * @public
-     * @returns A shallow copy of metadata.
+     * @internal
      */
-    getMetaFor(tagName: string): MetaElement | null;
+    everyChildren(callback: (node: HtmlElement) => boolean): boolean;
     /**
-     * Find all tags which has enabled given property.
+     * Visit all nodes from this node and down. Breadth first.
      *
-     * @public
+     * The first node for which the callback evaluates to true is returned.
+     *
+     * @internal
      */
-    getTagsWithProperty(propName: MetaLookupableProperty): string[];
+    find(callback: (node: HtmlElement) => boolean): HtmlElement | null;
+}
+
+declare class DOMTree {
+    readonly root: HtmlElement;
+    private active;
+    doctype: string | null;
+    constructor(location: Location);
+    pushActive(node: HtmlElement): void;
+    popActive(): void;
+    getActive(): HtmlElement;
     /**
-     * Find tag matching tagName or inheriting from it.
-     *
-     * @public
+     * Resolve dynamic meta expressions.
      */
-    getTagsDerivedFrom(tagName: string): string[];
-    private addEntry;
+    resolveMeta(table: MetaTable): void;
+    getElementsByTagName(tagName: string): HtmlElement[];
+    visitDepthFirst(callback: (node: HtmlElement) => void): void;
+    find(callback: (node: HtmlElement) => boolean): HtmlElement | null;
+    querySelector(selector: string): HtmlElement;
+    querySelectorAll(selector: string): HtmlElement[];
+}
+
+/**
+ * Represents a text in the HTML document.
+ *
+ * Text nodes are appended as children of `HtmlElement` and cannot have childen
+ * of its own.
+ *
+ * @public
+ */
+declare class TextNode extends DOMNode {
+    private readonly text;
     /**
-     * Construct a new AJV schema validator.
+     * @param text - Text to add. When a `DynamicValue` is used the expression is
+     * used as "text".
+     * @param location - Source code location of this node.
      */
-    private getSchemaValidator;
+    constructor(text: string | DynamicValue, location: Location);
     /**
-     * @public
+     * Get the text from node.
      */
-    getJSONSchema(): SchemaObject;
+    get textContent(): string;
     /**
-     * Finds the global element definition and merges each known element with the
-     * global, e.g. to assign global attributes.
+     * Flag set to true if the attribute value is static.
      */
-    private resolveGlobal;
-    private mergeElement;
+    get isStatic(): boolean;
     /**
-     * @internal
+     * Flag set to true if the attribute value is dynamic.
      */
-    resolve(node: HtmlElement): void;
+    get isDynamic(): boolean;
+}
+
+interface PermittedGroup {
+    exclude?: string | string[];
+}
+declare type CategoryOrTag = string;
+declare type PropertyExpression = string | [string, any];
+declare type PermittedEntry = CategoryOrTag | PermittedGroup | Array<CategoryOrTag | PermittedGroup>;
+declare type Permitted = PermittedEntry[];
+declare type PermittedOrder = string[];
+declare type RequiredAncestors = string[];
+declare type RequiredContent = string[];
+declare enum TextContent {
+    NONE = "none",
+    DEFAULT = "default",
+    REQUIRED = "required",
+    ACCESSIBLE = "accessible"
+}
+/**
+ * Callback for the `allowed` property of `MetaAttribute`. It takes a node and
+ * should return `null` if there is no errors and a string with an error
+ * description if there is an error.
+ *
+ * @public
+ */
+declare type MetaAttributeAllowedCallback = (node: HtmlElement) => string | null | undefined;
+/**
+ * @public
+ */
+interface MetaAttribute {
+    allowed?: MetaAttributeAllowedCallback;
+    boolean?: boolean;
+    deprecated?: boolean | string;
+    enum?: Array<string | RegExp>;
+    list?: boolean;
+    omit?: boolean;
+    required?: boolean;
+}
+declare type PermittedAttribute = Record<string, MetaAttribute | Array<string | RegExp> | null>;
+interface DeprecatedElement {
+    message?: string;
+    documentation?: string;
+    source?: string;
+}
+/**
+ * @public
+ */
+interface MetaData {
+    inherit?: string;
+    metadata?: boolean | PropertyExpression;
+    flow?: boolean | PropertyExpression;
+    sectioning?: boolean | PropertyExpression;
+    heading?: boolean | PropertyExpression;
+    phrasing?: boolean | PropertyExpression;
+    embedded?: boolean | PropertyExpression;
+    interactive?: boolean | PropertyExpression;
+    deprecated?: boolean | string | DeprecatedElement;
+    foreign?: boolean;
+    void?: boolean;
+    transparent?: boolean | string[];
+    implicitClosed?: string[];
+    scriptSupporting?: boolean;
+    form?: boolean;
+    labelable?: boolean | PropertyExpression;
+    deprecatedAttributes?: string[];
+    requiredAttributes?: string[];
+    attributes?: PermittedAttribute;
+    permittedContent?: Permitted;
+    permittedDescendants?: Permitted;
+    permittedOrder?: PermittedOrder;
+    permittedParent?: Permitted;
+    requiredAncestors?: RequiredAncestors;
+    requiredContent?: RequiredContent;
+    textContent?: TextContent | `${TextContent}`;
+}
+/**
+ * Properties listed here can be used to reverse search elements with the given
+ * property enabled. See [[MetaTable.getTagsWithProperty]].
+ */
+declare type MetaLookupableProperty = "metadata" | "flow" | "sectioning" | "heading" | "phrasing" | "embedded" | "interactive" | "deprecated" | "foreign" | "void" | "transparent" | "scriptSupporting" | "form" | "labelable";
+/**
+ * Properties listed here can be copied (loaded) onto another element using
+ * [[HtmlElement.loadMeta]].
+ *
+ * @public
+ */
+declare const MetaCopyableProperty: Array<keyof MetaElement>;
+/**
+ * @public
+ */
+interface MetaElement extends Omit<MetaData, "deprecatedAttributes" | "requiredAttributes"> {
+    tagName: string;
+    attributes: Record<string, MetaAttribute>;
+    textContent?: TextContent;
+}
+interface MetaDataTable {
+    [tagName: string]: MetaData;
+}
+interface ElementTable {
+    [tagName: string]: MetaElement;
 }
 
+/**
+ * Helper function to assist IDE with completion and type-checking.
+ *
+ * @public
+ */
+declare function defineMetadata(metatable: MetaDataTable): MetaDataTable;
+
+/**
+ * Helpers when writing element metadata.
+ *
+ * @public
+ */
+interface MetadataHelper {
+    /** Returns an error if another attribute is omitted, i.e. it requires another attribute to be present to pass. */
+    allowedIfAttributeIsPresent(...attr: string[]): MetaAttributeAllowedCallback;
+    /** Returns an error if another attribute is present, i.e. it requires another attribute to be omitted to pass. */
+    allowedIfAttributeIsAbsent(...attr: string[]): MetaAttributeAllowedCallback;
+    /** Returns an error if another attribute does not have one of the listed values */
+    allowedIfAttributeHasValue(attr: string, value: string[], options?: {
+        defaultValue?: string | null;
+    }): MetaAttributeAllowedCallback;
+}
+declare const metadataHelper: MetadataHelper;
+
 /**
  * @public
  */
@@ -2239,6 +2282,48 @@ declare class StaticConfigLoader extends ConfigLoader {
 /** @public */
 declare const version: string;
 
+declare const HTML_CACHE_KEY: unique symbol;
+declare const A11Y_CACHE_KEY: unique symbol;
+declare const IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY: unique symbol;
+declare const IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY: unique symbol;
+/**
+ * @public
+ */
+declare enum TextClassification {
+    EMPTY_TEXT = 0,
+    DYNAMIC_TEXT = 1,
+    STATIC_TEXT = 2
+}
+/**
+ * @public
+ */
+interface TextClassificationOptions {
+    /** If `true` only accessible text is considered (default false) */
+    accessible?: boolean;
+    /** If `true` the `hidden` and `aria-hidden` attribute is ignored on the root
+     * (and parents) elements (default false) */
+    ignoreHiddenRoot?: boolean;
+}
+declare module "../../dom/cache" {
+    interface DOMNodeCache {
+        [HTML_CACHE_KEY]: TextClassification;
+        [A11Y_CACHE_KEY]: TextClassification;
+        [IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY]: TextClassification;
+        [IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY]: TextClassification;
+    }
+}
+/**
+ * Checks text content of an element.
+ *
+ * Any text is considered including text from descendant elements. Whitespace is
+ * ignored.
+ *
+ * If any text is dynamic `TextClassification.DYNAMIC_TEXT` is returned.
+ *
+ * @public
+ */
+declare function classifyNodeText(node: HtmlElement, options?: TextClassificationOptions): TextClassification;
+
 /**
  * @public
  */
@@ -2345,4 +2430,4 @@ declare type Formatter = (results: Result[]) => string;
  */
 declare function getFormatter(name: string): Formatter | null;
 
-export { ElementReadyEvent as $, AttributeData as A, Parser as B, Config as C, DynamicValue as D, EventDump as E, ruleExists as F, EventHandler as G, HtmlValidate as H, EventCallback as I, Event as J, ConfigReadyEvent as K, Location as L, MetaData as M, NodeClosed as N, SourceReadyEvent as O, ProcessElementContext as P, TokenEvent as Q, Rule as R, Severity as S, TextNode as T, UserError as U, TagStartEvent as V, WrappedError as W, TagOpenEvent as X, TagEndEvent as Y, TagCloseEvent as Z, TagReadyEvent as _, ConfigData as a, AttributeEvent as a0, WhitespaceEvent as a1, ConditionalEvent as a2, DirectiveEvent as a3, DoctypeEvent as a4, DOMLoadEvent as a5, DOMReadyEvent as a6, TriggerEventMap as a7, ListenEventMap as a8, FileSystemConfigLoader as a9, Formatter as aa, getFormatter as ab, compatibilityCheck as ac, CompatibilityOptions as ad, ConfigError as b, ConfigLoader as c, StaticConfigLoader as d, HtmlElement as e, CSSStyleDeclaration as f, TokenDump as g, SchemaValidationError as h, NestedError as i, MetaDataTable as j, MetaElement as k, MetaTable as l, MetaCopyableProperty as m, RuleDocumentation as n, Source as o, presets as p, Report as q, Reporter as r, Message as s, Result as t, DeferredMessage as u, version as v, TransformContext as w, Transformer as x, TemplateExtractor as y, Plugin as z };
+export { TokenEvent as $, AttributeData as A, Result as B, Config as C, DynamicValue as D, EventDump as E, DeferredMessage as F, TransformContext as G, HtmlValidate as H, Transformer as I, TemplateExtractor as J, Plugin as K, Location as L, MetaData as M, NodeClosed as N, Parser as O, ProcessElementContext as P, ruleExists as Q, Rule as R, Severity as S, TextNode as T, UserError as U, EventHandler as V, WrappedError as W, EventCallback as X, Event as Y, ConfigReadyEvent as Z, SourceReadyEvent as _, ConfigData as a, TagStartEvent as a0, TagOpenEvent as a1, TagEndEvent as a2, TagCloseEvent as a3, TagReadyEvent as a4, ElementReadyEvent as a5, AttributeEvent as a6, WhitespaceEvent as a7, ConditionalEvent as a8, DirectiveEvent as a9, DoctypeEvent as aa, DOMLoadEvent as ab, DOMReadyEvent as ac, TriggerEventMap as ad, ListenEventMap as ae, FileSystemConfigLoader as af, Formatter as ag, getFormatter as ah, compatibilityCheck as ai, CompatibilityOptions as aj, ConfigError as b, ConfigLoader as c, StaticConfigLoader as d, HtmlElement as e, CSSStyleDeclaration as f, TokenDump as g, SchemaValidationError as h, NestedError as i, MetaDataTable as j, MetaElement as k, MetaAttribute as l, MetaAttributeAllowedCallback as m, MetaTable as n, MetaCopyableProperty as o, presets as p, defineMetadata as q, metadataHelper as r, RuleDocumentation as s, classifyNodeText as t, TextClassification as u, version as v, Source as w, Report as x, Reporter as y, Message as z };