@mpen/jsxhtml 0.2.2 → 0.4.0

package/dist/htmlspec/elements/img.d.ts

@@ -0,0 +1,90 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+import type { Numeric } from '../attributes/StandardGlobalAttributes';
+export interface ImgAttributes extends CommonAttributes<ElementForTag<'img'>> {
+    /**
+     * Defines text that can replace the image in the page. Setting this attribute to an empty string (`alt=""`) indicates that this image is _not_ a key part of the content (it's decoration or a tracking pixel), and that non-visual browsers may omit it from rendering. Visual browsers will also hide the broken image icon if the `alt` attribute is empty and the image failed to display. This attribute is also used when copying and pasting the image to text, or saving a linked image to a bookmark.
+     */
+    alt?: string;
+    /**
+     * The **`crossorigin`** attribute, valid on the audio, img, link, script, and video elements, provides support for CORS, defining how the element handles cross-origin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. Depending on the element, the attribute can be a CORS settings attribute.
+     */
+    crossorigin?: 'anonymous' | 'use-credentials';
+    /**
+     * This attribute provides a hint to the browser as to whether it should perform image decoding along with rendering the other DOM content in a single presentation step that looks more "correct" (`sync`), or render and present the other DOM content first and then decode the image and present it later (`async`). In practice, `async` means that the next paint does not wait for the image to decode. It is often difficult to perceive any noticeable effect when using `decoding` on static `<img ` elements. They'll likely be initially rendered as empty images while the image files are fetched (either from the network or from the cache) and then handled independently anyway, so the "syncing" of content updates is less apparent. However, the blocking of rendering while decoding happens, while often quite small, _can_ be measured - even if it is difficult to observe with the human eye. See What does the image decoding attribute actually do? for a more detailed analysis (tunetheweb.com, 2023). Using different `decoding` types can result in more noticeable differences when dynamically inserting `<img ` elements into the DOM via JavaScript - see HTMLImageElement.decoding for more details. Allowed values: Decode the image synchronously along with rendering the other DOM content, and present everything together. Decode the image asynchronously, after rendering and presenting the other DOM content. No preference for the decoding mode; the browser decides what is best for the user. This is the default value.
+     *
+     * Possible values:
+     * - sync
+     * - async
+     * - auto
+     */
+    decoding?: 'sync' | 'async' | 'auto';
+    /**
+     * The **`elementtiming`** attribute is used to indicate that an element is flagged for tracking by PerformanceObserver objects using the `"element"` type. For more details, see the PerformanceElementTiming interface.
+     */
+    elementtiming?: string;
+    /**
+     * The **`fetchpriority`** attribute allows a developer to signal that fetching a particular image early in the loading process has more or less impact on user experience than a browser can reasonably infer when assigning an internal priority. This in turn allows the browser to increase or decrease the priority, and potentially load the image earlier or later than it would otherwise.
+     */
+    fetchpriority?: 'high' | 'low' | 'auto';
+    /**
+     * The intrinsic height of the image, in pixels. Must be an integer without a unit.
+     */
+    height?: Numeric;
+    /**
+     * This Boolean attribute indicates that the image is part of a server-side map. If so, the coordinates where the user clicked on the image are sent to the server.
+     */
+    ismap?: boolean;
+    /**
+     * Indicates how the browser should load the image: Loads the image immediately, regardless of whether or not the image is currently within the visible viewport (this is the default value). Defers loading the image until it reaches a calculated distance from the viewport, as defined by the browser. The intent is to avoid the network and storage bandwidth needed to handle the image until it's reasonably certain that it will be needed. This generally improves the performance of the content in most typical use cases. While explicit `width` and `height` attributes are recommended for all images to avoid layout shift, they are especially important for lazy-loaded ones. Lazy-loaded images will never be loaded if they do not intersect a visible part of an element, even if loading them would change that, because unloaded images have a `width` and `height` of `0`. It creates an even more disruptive user experience when the content visible in the viewport reflows in the middle of reading it. The load event is fired after eager-loaded images have been fetched and processed, but before lazy-laded ones are, even if the lazy-loaded images are located within the visual viewport immediately upon initial page load. These images are still loaded as soon as layout completes; they just don't affect the timing of the `load` event. That means that when `load` fires, it's possible that any lazy-loaded images located in the visual viewport may not yet be visible. Loading is only deferred when JavaScript is enabled. This is an anti-tracking measure, because if a user agent supported lazy loading when scripting is disabled, it would still be possible for a site to track a user's approximate scroll position throughout a session, by strategically placing images in a page's markup such that a server can track how many images are requested and when.
+     *
+     * Possible values:
+     * - eager
+     * - lazy
+     */
+    loading?: 'eager' | 'lazy';
+    /**
+     * A string indicating which referrer to use when fetching the resource:
+     *
+     * Possible values:
+     * - no-referrer
+     * - no-referrer-when-downgrade
+     * - origin
+     * - origin-when-cross-origin
+     * - same-origin
+     * - strict-origin
+     * - strict-origin-when-cross-origin
+     * - unsafe-url
+     */
+    referrerpolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+    /**
+     * One or more values separated by commas, which can be source sizes or the `auto` keyword. The spec requires that the `sizes` attribute to only be present when `srcset` uses width descriptors. A **source size** consists of: 1. A media condition, omitted for the last item in the list. 2. A source size value. Media conditions describe properties of the _viewport_, not the _image_. For example, `(height <= 500px) 1000px` proposes using an image source of 1000px width if the _viewport_ height is 500px or less. Because a source size descriptor specifies the width to use for the image during layout, the media condition is typically (but not necessarily) based on the @media/width. Source size values specify the intended display size of the image. User agents use the current source size to select one of the sources supplied by the `srcset` attribute, when those sources are described using width (`w`) descriptors. The selected source size affects the intrinsic size of the image (the image's display size if no CSS styling is applied). A source size value can be any non-negative length. It must not use CSS functions other than the math functions. Units are interpreted in the same way as media queries, meaning that all relative length units are relative to the document root rather than the `<img ` element. For example, an `em` value is relative to the root font size, not the font size of the image. Percentage values are not allowed. If the `sizes` attribute is not provided, it has a default value of `100vw` (the viewport width). The `auto` keyword can replace the whole list of sizes or the first entry in the list. It is only valid when combined with `loading="lazy"`, and resolves to the concrete size of the image. Since the intrinsic size of the image is not yet known, `width` and `height` attributes (or CSS equivalents) should also be specified to prevent the browser from assuming the default image width of 300px. For better backward compatibility with browsers that do not support `auto`, you can include fallback sizes after `auto` in the `sizes` attribute:
+     */
+    sizes?: string;
+    /**
+     * One or more strings separated by commas, indicating possible image sources for the user agent to use. Each string is composed of: 1. A URL to an image 2. Optionally, whitespace followed by one of: If no descriptor is specified, the source is assigned the default descriptor of `1x`. It is incorrect to mix width descriptors and pixel density descriptors in the same `srcset` attribute. Duplicate descriptors (for instance, two sources in the same `srcset` which are both described with `2x`) are also invalid. Space characters, other than the whitespace separating the URL and the corresponding condition descriptor, are ignored; this includes both leading and trailing space, as well as space before or after each comma. However, if an image candidate string contains no descriptors and no whitespace after the URL, the following image candidate string, if there is one, must begin with one or more whitespace, or the comma will be considered part of the URL. When the `<img ` element's `srcset` uses `x` descriptors, browsers also consider the URL in the `src` attribute (if present) as a candidate, and assign it a default descriptor of `1x`. On the other hand, if the `srcset` attribute uses width descriptors, `src` is not considered, and the `sizes` attribute is used instead. The user agent selects any of the available sources at its discretion. This provides them with significant leeway to tailor their selection based on things like user preferences or bandwidth conditions. See our Responsive images tutorial for an example.
+     */
+    srcset?: string;
+    /**
+     * The image URL. At least one of `src` and `srcset` is required for an `<img ` element. If `srcset` is specified, `src` is used in one of two ways:
+     */
+    src?: string;
+    /**
+     * The intrinsic width of the image in pixels. Must be an integer without a unit.
+     */
+    width?: Numeric;
+    /**
+     * The partial URL (starting with `#`) of an image map associated with the element.
+     */
+    usemap?: string;
+    /**
+     * Equivalent to `vertical-align: top` or `vertical-align: text-top` Equivalent to `vertical-align: -moz-middle-with-baseline` The default, equivalent to `vertical-align: unset` or `vertical-align: initial` Equivalent to `float: left` Equivalent to `float: right`
+     *
+     * Possible values:
+     * - middle
+     * - bottom
+     * - left
+     * - right
+     */
+    top?: 'middle' | 'bottom' | 'left' | 'right';
+}

package/dist/htmlspec/elements/index.d.ts

@@ -0,0 +1,114 @@
+export type { AAttributes } from './a';
+export type { AbbrAttributes } from './abbr';
+export type { AddressAttributes } from './address';
+export type { AreaAttributes } from './area';
+export type { ArticleAttributes } from './article';
+export type { AsideAttributes } from './aside';
+export type { AudioAttributes } from './audio';
+export type { BAttributes } from './b';
+export type { BaseAttributes } from './base';
+export type { BdiAttributes } from './bdi';
+export type { BdoAttributes } from './bdo';
+export type { BlockquoteAttributes } from './blockquote';
+export type { BodyAttributes } from './body';
+export type { BrAttributes } from './br';
+export type { ButtonAttributes } from './button';
+export type { CanvasAttributes } from './canvas';
+export type { CaptionAttributes } from './caption';
+export type { CiteAttributes } from './cite';
+export type { CodeAttributes } from './code';
+export type { ColAttributes } from './col';
+export type { ColgroupAttributes } from './colgroup';
+export type { DataAttributes } from './data';
+export type { DatalistAttributes } from './datalist';
+export type { DdAttributes } from './dd';
+export type { DelAttributes } from './del';
+export type { DetailsAttributes } from './details';
+export type { DfnAttributes } from './dfn';
+export type { DialogAttributes } from './dialog';
+export type { DivAttributes } from './div';
+export type { DlAttributes } from './dl';
+export type { DtAttributes } from './dt';
+export type { EmAttributes } from './em';
+export type { EmbedAttributes } from './embed';
+export type { FencedframeAttributes } from './fencedframe';
+export type { FieldsetAttributes } from './fieldset';
+export type { FigcaptionAttributes } from './figcaption';
+export type { FigureAttributes } from './figure';
+export type { FooterAttributes } from './footer';
+export type { FormAttributes } from './form';
+export type { H1Attributes } from './h1';
+export type { H2Attributes } from './h2';
+export type { H3Attributes } from './h3';
+export type { H4Attributes } from './h4';
+export type { H5Attributes } from './h5';
+export type { H6Attributes } from './h6';
+export type { HeadAttributes } from './head';
+export type { HeaderAttributes } from './header';
+export type { HgroupAttributes } from './hgroup';
+export type { HrAttributes } from './hr';
+export type { HtmlAttributes } from './html';
+export type { IAttributes } from './i';
+export type { IframeAttributes } from './iframe';
+export type { ImgAttributes } from './img';
+export type { InputAttributes } from './input';
+export type { InsAttributes } from './ins';
+export type { KbdAttributes } from './kbd';
+export type { LabelAttributes } from './label';
+export type { LegendAttributes } from './legend';
+export type { LiAttributes } from './li';
+export type { LinkAttributes } from './link';
+export type { MainAttributes } from './main';
+export type { MapAttributes } from './map';
+export type { MarkAttributes } from './mark';
+export type { MenuAttributes } from './menu';
+export type { MetaAttributes } from './meta';
+export type { MeterAttributes } from './meter';
+export type { NavAttributes } from './nav';
+export type { NoscriptAttributes } from './noscript';
+export type { ObjectAttributes } from './object';
+export type { OlAttributes } from './ol';
+export type { OptgroupAttributes } from './optgroup';
+export type { OptionAttributes } from './option';
+export type { OutputAttributes } from './output';
+export type { PAttributes } from './p';
+export type { PictureAttributes } from './picture';
+export type { PreAttributes } from './pre';
+export type { ProgressAttributes } from './progress';
+export type { QAttributes } from './q';
+export type { RpAttributes } from './rp';
+export type { RtAttributes } from './rt';
+export type { RubyAttributes } from './ruby';
+export type { SAttributes } from './s';
+export type { SampAttributes } from './samp';
+export type { ScriptAttributes } from './script';
+export type { SearchAttributes } from './search';
+export type { SectionAttributes } from './section';
+export type { SelectAttributes } from './select';
+export type { SelectedcontentAttributes } from './selectedcontent';
+export type { SlotAttributes } from './slot';
+export type { SmallAttributes } from './small';
+export type { SourceAttributes } from './source';
+export type { SpanAttributes } from './span';
+export type { StrongAttributes } from './strong';
+export type { StyleAttributes } from './style';
+export type { SubAttributes } from './sub';
+export type { SummaryAttributes } from './summary';
+export type { SupAttributes } from './sup';
+export type { TableAttributes } from './table';
+export type { TbodyAttributes } from './tbody';
+export type { TdAttributes } from './td';
+export type { TemplateAttributes } from './template';
+export type { TextareaAttributes } from './textarea';
+export type { TfootAttributes } from './tfoot';
+export type { ThAttributes } from './th';
+export type { TheadAttributes } from './thead';
+export type { TimeAttributes } from './time';
+export type { TitleAttributes } from './title';
+export type { TrAttributes } from './tr';
+export type { TrackAttributes } from './track';
+export type { UAttributes } from './u';
+export type { UlAttributes } from './ul';
+export type { VarAttributes } from './var';
+export type { VideoAttributes } from './video';
+export type { WbrAttributes } from './wbr';

package/dist/htmlspec/elements/input.d.ts

@@ -0,0 +1,189 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+import type { Numeric } from '../attributes/StandardGlobalAttributes';
+/**
+ * A union of all possible 'type' attribute values for the <input> element.
+ */
+export type InputType = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week';
+/**
+ * Type definition for the attributes of the HTML <input> element, excluding global attributes.
+ * The <input> element is used to create interactive controls for web-based forms to accept data from the user.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input
+ */
+export interface InputAttributes extends CommonAttributes<ElementForTag<'input'>> {
+    /**
+     * The **`accept`** attribute takes as its value a comma-separated list of one or more file types, or unique file type specifiers, describing which file types to allow.
+     */
+    accept?: string;
+    /**
+     * Valid for the `image` button only, the `alt` attribute provides alternative text for the image, displaying the value of the attribute if the image `src` is missing or otherwise fails to load. See the image input type.
+     */
+    alt?: string;
+    /**
+     * Controls whether the browser may automatically complete the value and provides guidance about the type of information expected in the field.
+     *
+     * Possible values:
+     * - off
+     * - on
+     */
+    autocomplete?: 'on' | 'off' | string;
+    /**
+     * The **`capture`** attribute specifies that, optionally, a new file should be captured, and which device should be used to capture that new media of a type defined by the `accept` attribute.
+     */
+    capture?: boolean | 'user' | 'environment';
+    /**
+     * Valid for both `radio` and `checkbox` types, `checked` is a Boolean attribute. If present on a `radio` type, it indicates that the radio button is the currently selected one in the group of same-named radio buttons. If present on a `checkbox` type, it indicates that the checkbox is checked by default (when the page loads). It does _not_ indicate whether this checkbox is currently checked: if the checkbox's state is changed, this content attribute does not reflect the change. (Only the `HTMLInputElement`'s `checked` IDL attribute is updated.)
+     */
+    checked?: boolean;
+    /**
+     * The **`dirname`** attribute can be used on the textarea element and several input types and describes the directionality of the element's text content during form submission. The browser uses this attribute's value to determine whether text the user has entered is left-to-right or right-to-left oriented. When used, the element's text directionality value is included in form submission data along with the `dirname` attribute's value as the name of the field.
+     */
+    dirname?: string;
+    /**
+     * The Boolean **`disabled`** attribute, when present, makes the element not mutable, focusable, or even submitted with the form. The user can neither edit nor focus on the control, nor its form control descendants.
+     */
+    disabled?: boolean;
+    /**
+     * The `form` HTML attribute associates a form-associated element with a form element within the same document. This attribute applies to the button, fieldset, input, object, output, select, and textarea elements.
+     */
+    form?: string;
+    /**
+     * Valid for the `image` and `submit` input types only. See the submit input type for more information.
+     */
+    formaction?: string;
+    /**
+     * Valid for the `image` and `submit` input types only. See the submit input type for more information.
+     */
+    formenctype?: 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain';
+    /**
+     * Valid for the `image` and `submit` input types only. See the submit input type for more information.
+     */
+    formmethod?: 'get' | 'post';
+    /**
+     * Valid for the `image` and `submit` input types only. See the submit input type for more information.
+     */
+    formnovalidate?: boolean;
+    /**
+     * Valid for the `image` and `submit` input types only. See the submit input type for more information.
+     */
+    formtarget?: string;
+    /**
+     * Valid for the `image` input button only, the `height` is the height of the image file to display to represent the graphical submit button. See the image input type.
+     */
+    height?: Numeric;
+    /**
+     * The value given to the `list` attribute should be the id of a datalist element located in the same document. The `<datalist ` provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the `type` are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value. It is valid on `text`, `search`, `url`, `tel`, `email`, `date`, `month`, `week`, `time`, `datetime-local`, `number`, `range`, and `color`. Per the specifications, the `list` attribute is not supported by the `hidden`, `password`, `checkbox`, `radio`, `file`, or any of the button types. Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even an input that opens like a select but allows for non-listed values. Check out the browser compatibility table for the other input types. See the datalist element.
+     */
+    list?: string;
+    /**
+     * The **`max`** attribute defines the maximum value that is acceptable and valid for the input containing the attribute. If the `value` of the element is greater than this, the element fails validation. This value must be greater than or equal to the value of the `min` attribute. If the `max` attribute is present but is not specified or is invalid, no `max` value is applied. If the `max` attribute is valid and a non-empty value is greater than the maximum allowed by the `max` attribute, constraint validation will prevent form submission.
+     */
+    max?: string | Numeric;
+    /**
+     * The **`maxlength`** attribute defines the maximum string length that the user can enter into an input or textarea. The attribute must have an integer value of 0 or higher.
+     */
+    maxlength?: Numeric;
+    /**
+     * The **`min`** attribute defines the minimum value that is acceptable and valid for the input containing the attribute. If the `value` of the element is less than this, the element fails validation. This value must be less than or equal to the value of the `max` attribute.
+     */
+    min?: string | Numeric;
+    /**
+     * The **`minlength`** attribute defines the minimum string length that the user can enter into an input or textarea. The attribute must have an integer value of 0 or higher.
+     */
+    minlength?: Numeric;
+    /**
+     * The Boolean **`multiple`** attribute, if set, means the form control accepts one or more values. The attribute is valid for the email and file input types and the select. The manner by which the user opts for multiple values depends on the form control.
+     */
+    multiple?: boolean;
+    /**
+     * A string specifying a name for the input control. This name is submitted along with the control's value when the form data is submitted. Consider the `name` a required attribute (even though it's not). If an input has no `name` specified, or `name` is empty, the input's value is not submitted with the form! (Disabled controls, unchecked radio buttons, unchecked checkboxes, and reset buttons are also not sent.) There are two special cases: 1. `_charset_` : If used as the name of an `<input ` element of type hidden, the input's `value` is automatically set by the user agent to the character encoding being used to submit the form. 2. `isindex`: For historical reasons, the name `isindex` is not allowed. The `name` attribute creates a unique behavior for radio buttons. Only one radio button in a same-named group of radio buttons can be checked at a time. Selecting any radio button in that group automatically deselects any currently-selected radio button in the same group. The value of that one checked radio button is sent along with the name if the form is submitted, When tabbing into a series of same-named group of radio buttons, if one is checked, that one will receive focus. If they aren't grouped together in source order, if one of the group is checked, tabbing into the group starts when the first one in the group is encountered, skipping all those that aren't checked. In other words, if one is checked, tabbing skips the unchecked radio buttons in the group. If none are checked, the radio button group receives focus when the first button in the same name group is reached. Once one of the radio buttons in a group has focus, using the arrow keys will navigate through all the radio buttons of the same name, even if the radio buttons are not grouped together in the source order. When an input element is given a `name`, that name becomes a property of the owning form element's HTMLFormElement.elements property. If you have an input whose `name` is set to `guest` and another whose `name` is `hat-size`, the following code can be used:
+     */
+    name?: string;
+    /**
+     * The **`pattern`** attribute specifies a regular expression the form control's value should match. If a non-`null` value doesn't conform to the constraints set by the `pattern` value, the ValidityState object's read-only patternMismatch property will be true.
+     */
+    pattern?: string;
+    /**
+     * The **`placeholder`** attribute defines the text displayed in a form control when the control has no value. The placeholder text should provide a brief hint to the user as to the expected type of data that should be entered into the control.
+     */
+    placeholder?: string;
+    /**
+     * Turns an `<input type="button" ` element into a popover control button; takes the ID of the popover element to control as its value. See the Popover API landing page for more details. Establishing a relationship between a popover and its invoker button using the `popovertarget` attribute has two additional useful effects:
+     */
+    popovertarget?: string;
+    /**
+     * Specifies the action to be performed on a popover element being controlled by a control `<input type="button" `. Possible values are: The button will hide a shown popover. If you try to hide an already hidden popover, no action will be taken. The button will show a hidden popover. If you try to show an already showing popover, no action will be taken. The button will toggle a popover between showing and hidden. If the popover is hidden, it will be shown; if the popover is showing, it will be hidden. If `popovertargetaction` is omitted, `"toggle"` is the default action that will be performed by the control button.
+     *
+     * Possible values:
+     * - hide
+     * - show
+     * - toggle
+     */
+    popovertargetaction?: 'hide' | 'show' | 'toggle';
+    /**
+     * The Boolean **`readonly`** attribute, when present, makes the element not mutable, meaning the user can not edit the control.
+     */
+    readonly?: boolean;
+    /**
+     * The Boolean **`required`** attribute, if present, indicates that the user must specify a value for the input before the owning form can be submitted.
+     */
+    required?: boolean;
+    /**
+     * The **`size`** attribute defines the width of the input and the height of the select element. For an `input` element, it defines the number of characters that the user agent allows the user to see when editing the value. For a `select` element, it defines the number of options that should be shown to the user. This must be a valid non-negative integer greater than zero.
+     */
+    size?: Numeric;
+    /**
+     * Valid for the `image` input button only, the `src` is string specifying the URL of the image file to display to represent the graphical submit button. See the image input type.
+     */
+    src?: string;
+    /**
+     * The **`step`** attribute is a number that specifies the granularity that the value must adhere to or the keyword `any`. It is valid for the numeric input types, including the date, month, week, time, datetime-local, number and range types.
+     */
+    step?: Numeric | 'any';
+    /**
+     * A string specifying the type of control to render. For example, to create a checkbox, a value of `checkbox` is used. If omitted (or an unknown value is specified), the input type `text` is used, creating a plaintext input field. Permitted values are listed in Input types above.
+     */
+    type?: InputType;
+    /**
+     * The input control's value. When specified in the HTML, this is the initial value, and from then on it can be altered or retrieved at any time using JavaScript to access the respective HTMLInputElement object's `value` property. The `value` attribute is always optional, though should be considered mandatory for `checkbox`, `radio`, and `hidden`.
+     */
+    value?: string | Numeric;
+    /**
+     * Valid for the `image` input button only, the `width` is the width of the image file to display to represent the graphical submit button. See the image input type.
+     */
+    width?: Numeric;
+    /**
+     * The Boolean attribute `incremental` is a WebKit and Blink extension (so supported by Safari, Opera, Chrome, etc.) which, if present, tells the user agent to process the input as a live search. As the user edits the value of the field, the user agent sends search events to the HTMLInputElement object representing the search box. This allows your code to update the search results in real time as the user edits the search. If `incremental` is not specified, the search event is only sent when the user explicitly initiates a search (such as by pressing the <kbd Enter</kbd or <kbd Return</kbd key while editing the field). The `search` event is rate-limited so that it is not sent more frequently than an implementation-defined interval.
+     * @experimental
+     */
+    incremental?: boolean;
+    /**
+     * Similar to the -moz-orient non-standard CSS property impacting the progress and meter elements, the `orient` attribute defines the orientation of the range slider. Values include `horizontal`, meaning the range is rendered horizontally, and `vertical`, where the range is rendered vertically. See Creating vertical form controls for a modern approach to creating vertical form controls.
+     * @experimental
+     */
+    orient?: 'horizontal' | 'vertical';
+    /**
+     * The `results` attribute-supported only by Safari-is a numeric value that lets you override the maximum number of entries to be displayed in the `<input ` element's natively-provided drop-down menu of previous search queries. The value must be a non-negative decimal number. If not provided, or an invalid value is given, the browser's default maximum number of entries is used.
+     * @experimental
+     */
+    results?: Numeric;
+    /**
+     * The Boolean `webkitdirectory` attribute, if present, indicates that only directories should be available to be selected by the user in the file picker interface. See HTMLInputElement.webkitdirectory for additional details and examples. Though originally implemented only for WebKit-based browsers, `webkitdirectory` is also usable in Microsoft Edge as well as Firefox 50 and later. However, even though it has relatively broad support, it is still not standard and should not be used unless you have no alternative.
+     * @experimental
+     */
+    webkitdirectory?: boolean;
+    /**
+     * Valid for the `color` input type only, the `alpha` attribute provides the end user with the ability to set the opacity of the color being selected.
+     * @experimental
+     */
+    alpha?: boolean;
+    /**
+     * Valid for the `color` input type only, the `colorspace` attribute specifies the color space that is used by the `type="color"` input. Possible enumerated values are:
+     *
+     * Possible values:
+     * - limited-srgb
+     * - display-p3
+     * @experimental
+     */
+    colorspace?: 'limited-srgb' | 'display-p3';
+}

package/dist/htmlspec/elements/ins.d.ts

@@ -0,0 +1,12 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface InsAttributes extends CommonAttributes<ElementForTag<'ins'>> {
+    /**
+     * This attribute defines the URI of a resource that explains the change, such as a link to meeting minutes or a ticket in a troubleshooting system.
+     */
+    cite?: string;
+    /**
+     * This attribute indicates the time and date of the change and must be a valid date with an optional time string. If the value cannot be parsed as a date with an optional time string, the element does not have an associated timestamp. For the format of the string without a time, see Format of a valid date string. The format of the string if it includes both date and time is covered in Format of a valid local date and time string.
+     */
+    datetime?: string;
+}

package/dist/htmlspec/elements/kbd.d.ts

@@ -0,0 +1,4 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface KbdAttributes extends CommonAttributes<ElementForTag<'kbd'>> {
+}

package/dist/htmlspec/elements/label.d.ts

@@ -0,0 +1,8 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface LabelAttributes extends CommonAttributes<ElementForTag<'label'>> {
+    /**
+     * The **`for`** attribute is an allowed attribute for label and output. When used on a `<label ` element it indicates the form element that this label describes. When used on an `<output ` element it allows for an explicit relationship between the elements that represent values which are used in the output.
+     */
+    for?: string;
+}

package/dist/htmlspec/elements/legend.d.ts

@@ -0,0 +1,4 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface LegendAttributes extends CommonAttributes<ElementForTag<'legend'>> {
+}

package/dist/htmlspec/elements/li.d.ts

@@ -0,0 +1,19 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+import type { Numeric } from '../attributes/StandardGlobalAttributes';
+export interface LiAttributes extends CommonAttributes<ElementForTag<'li'>> {
+    /**
+     * This integer attribute indicates the current ordinal value of the list item as defined by the ol element. The only allowed value for this attribute is a number, even if the list is displayed with Roman numerals or letters. List items that follow this one continue numbering from the value set. This attribute has no meaning for unordered lists (ul) or for menus (menu).
+     */
+    value?: string | Numeric;
+    /**
+     * This type overrides the one used by its parent ol element, if any.
+     *
+     * Possible values:
+     * - A
+     * - i
+     * - I
+     * - 1
+     */
+    a?: 'A' | 'i' | 'I' | '1';
+}

package/dist/htmlspec/elements/link.d.ts

@@ -0,0 +1,77 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface LinkAttributes extends CommonAttributes<ElementForTag<'link'>> {
+    /**
+     * This attribute is required when `rel="preload"` has been set on the `<link ` element, optional when `rel="modulepreload"` has been set, and otherwise should not be used. It specifies the type of content being loaded by the `<link `, which is necessary for request matching, application of correct content security policy, and setting of correct Accept request header. Furthermore, `rel="preload"` uses this as a signal for request prioritization. The table below lists the valid values for this attribute and the elements or resources they apply to.
+     */
+    as?: string;
+    /**
+     * This attribute explicitly indicates that certain operations should be blocked until specific conditions are met. It must only be used when the `rel` attribute contains the `expect` or `stylesheet` keywords. With `rel="expect"`, it indicates that operations should be blocked until a specific DOM node has been parsed. With `rel="stylesheet"`, it indicates that operations should be blocked until an external stylesheet and its critical subresources have been fetched and applied to the document. The operations that are to be blocked must be a space-separated list of blocking tokens listed below. Currently there is only one token:
+     *
+     * Possible values:
+     * - render
+     */
+    blocking?: 'render';
+    /**
+     * The **`crossorigin`** attribute, valid on the audio, img, link, script, and video elements, provides support for CORS, defining how the element handles cross-origin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. Depending on the element, the attribute can be a CORS settings attribute.
+     */
+    crossorigin?: 'anonymous' | 'use-credentials';
+    /**
+     * The Boolean **`disabled`** attribute, when present, makes the element not mutable, focusable, or even submitted with the form. The user can neither edit nor focus on the control, nor its form control descendants.
+     */
+    disabled?: boolean;
+    /**
+     * The **`fetchpriority`** attribute allows a developer to signal that fetching a particular image early in the loading process has more or less impact on user experience than a browser can reasonably infer when assigning an internal priority. This in turn allows the browser to increase or decrease the priority, and potentially load the image earlier or later than it would otherwise.
+     */
+    fetchpriority?: 'high' | 'low' | 'auto';
+    /**
+     * This attribute specifies the URL of the linked resource. A URL can be absolute or relative.
+     */
+    href?: string;
+    /**
+     * This attribute indicates the language of the linked resource. It is purely advisory. Values should be valid BCP 47 language tags. Use this attribute only if the `href` attribute is present.
+     */
+    hreflang?: string;
+    /**
+     * For `rel="preload"` and `as="image"` only, the `imagesizes` attribute has similar syntax and semantics as the `sizes` attribute that indicates to preload the appropriate resource used by an `img` element with corresponding values for its `srcset` and `sizes` attributes.
+     */
+    imagesizes?: string;
+    /**
+     * For `rel="preload"` and `as="image"` only, the `imagesrcset` attribute has similar syntax and semantics as the `srcset` attribute that indicates to preload the appropriate resource used by an `img` element with corresponding values for its `srcset` and `sizes` attributes.
+     */
+    imagesrcset?: string;
+    /**
+     * Contains inline metadata - a base64-encoded cryptographic hash of the resource (file) you're telling the browser to fetch. The browser can use this to verify that the fetched resource has been delivered without unexpected manipulation. The attribute must only be specified when the `rel` attribute is specified to `stylesheet`, `preload`, or `modulepreload`. See Subresource Integrity.
+     */
+    integrity?: string;
+    /**
+     * This attribute specifies the media that the linked resource applies to. Its value must be a media type / media query. This attribute is mainly useful when linking to external stylesheets - it allows the user agent to pick the best adapted one for the device it runs on.
+     */
+    media?: string;
+    /**
+     * A string indicating which referrer to use when fetching the resource: This is a user agent's default behavior, if no policy is otherwise specified. This case is unsafe because it can leak origins and paths from TLS-protected resources to insecure origins.
+     *
+     * Possible values:
+     * - no-referrer
+     * - no-referrer-when-downgrade
+     * - origin
+     * - origin-when-cross-origin
+     * - unsafe-url
+     */
+    referrerpolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'unsafe-url';
+    /**
+     * The **`rel`** attribute defines the relationship between a linked resource and the current document. Valid on link, a, area, and form, the supported values depend on the element on which the attribute is found.
+     */
+    rel?: string;
+    /**
+     * This attribute defines the sizes of the icons for visual media contained in the resource. It must be present only if the `rel` contains a value of `icon` or a non-standard type such as Apple's `apple-touch-icon`. It may have the following values:
+     *
+     * Possible values:
+     * - any
+     */
+    sizes?: 'any';
+    /**
+     * This attribute is used to define the type of the content linked to. The value of the attribute should be a MIME type such as **text/html**, **text/css**, and so on. The common use of this attribute is to define the type of stylesheet being referenced (such as **text/css**), but given that CSS is the only stylesheet language used on the web, not only is it possible to omit the `type` attribute, but is actually now recommended practice. It is also used on `rel="preload"` link types, to make sure the browser only downloads file types that it supports.
+     */
+    type?: string;
+}

package/dist/htmlspec/elements/main.d.ts

@@ -0,0 +1,4 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface MainAttributes extends CommonAttributes<ElementForTag<'main'>> {
+}

package/dist/htmlspec/elements/map.d.ts

@@ -0,0 +1,8 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface MapAttributes extends CommonAttributes<ElementForTag<'map'>> {
+    /**
+     * The `name` attribute gives the map a name so that it can be referenced. The attribute must be present and must have a non-empty value with no space characters. The value of the `name` attribute must not be equal to the value of the `name` attribute of another `<map ` element in the same document. If the `id` attribute is also specified, both attributes must have the same value.
+     */
+    name?: string;
+}

package/dist/htmlspec/elements/mark.d.ts

@@ -0,0 +1,4 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface MarkAttributes extends CommonAttributes<ElementForTag<'mark'>> {
+}

package/dist/htmlspec/elements/menu.d.ts

@@ -0,0 +1,4 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface MenuAttributes extends CommonAttributes<ElementForTag<'menu'>> {
+}

package/dist/htmlspec/elements/meta.d.ts

@@ -0,0 +1,24 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+export interface MetaAttributes extends CommonAttributes<ElementForTag<'meta'>> {
+    /**
+     * This attribute declares the document's character encoding. If the attribute is present, its value must be an ASCII case-insensitive match for the string `"utf-8"`, because UTF-8 is the only valid encoding for HTML5 documents. `<meta ` elements which declare a character encoding must be located entirely within the first 1024 bytes of the document.
+     */
+    charset?: string;
+    /**
+     * The **`content`** attribute specifies the value of a metadata name defined by the `<meta ` `name` attribute. It takes a string as its value, and the expected syntax varies depending on the `name` value used.
+     */
+    content?: string;
+    /**
+     * The `name` and `content` attributes can be used together to provide document metadata in terms of name-value pairs, with the `name` attribute giving the metadata name, and the `content` attribute giving the value.
+     */
+    name?: string;
+    /**
+     * Defines a pragma directive, which are instructions for the browser for processing the document. The attribute's name is short for `http-equivalent` because the allowed values are names of equivalent HTTP headers.
+     */
+    'http-equiv'?: string;
+    /**
+     * The `media` attribute defines which media the theme color defined in the `content` attribute should be applied to. Its value is a media query, which defaults to `all` if the attribute is missing. This attribute is only relevant when the element's `name` attribute is set to `theme-color`. Otherwise, it has no effect, and should not be included.
+     */
+    media?: string;
+}

package/dist/htmlspec/elements/meter.d.ts

@@ -0,0 +1,29 @@
+import type { CommonAttributes } from '../attributes/ElementAttributes';
+import type { ElementForTag } from './element-types';
+import type { Numeric } from '../attributes/StandardGlobalAttributes';
+export interface MeterAttributes extends CommonAttributes<ElementForTag<'meter'>> {
+    /**
+     * The current numeric value. This must be between the minimum and maximum values (`min` attribute and `max` attribute) if they are specified. If unspecified or malformed, the value is `0`. If specified, but not within the range given by the `min` attribute and `max` attribute, the value is equal to the nearest end of the range.
+     */
+    value?: string | Numeric;
+    /**
+     * The **`min`** attribute defines the minimum value that is acceptable and valid for the input containing the attribute. If the `value` of the element is less than this, the element fails validation. This value must be less than or equal to the value of the `max` attribute.
+     */
+    min?: string | Numeric;
+    /**
+     * The **`max`** attribute defines the maximum value that is acceptable and valid for the input containing the attribute. If the `value` of the element is greater than this, the element fails validation. This value must be greater than or equal to the value of the `min` attribute. If the `max` attribute is present but is not specified or is invalid, no `max` value is applied. If the `max` attribute is valid and a non-empty value is greater than the maximum allowed by the `max` attribute, constraint validation will prevent form submission.
+     */
+    max?: string | Numeric;
+    /**
+     * The upper numeric bound of the low end of the measured range. This must be greater than the minimum value (`min` attribute), and it also must be less than the high value and maximum value (`high` attribute and `max` attribute, respectively), if any are specified. If unspecified, or if less than the minimum value, the `low` value is equal to the minimum value.
+     */
+    low?: Numeric;
+    /**
+     * The lower numeric bound of the high end of the measured range. This must be less than the maximum value (`max` attribute), and it also must be greater than the low value and minimum value (`low` attribute and `min` attribute, respectively), if any are specified. If unspecified, or if greater than the maximum value, the `high` value is equal to the maximum value.
+     */
+    high?: Numeric;
+    /**
+     * This attribute indicates the optimal numeric value. It must be within the range (as defined by the `min` attribute and `max` attribute). When used with the `low` attribute and `high` attribute, it gives an indication where along the range is considered preferable. For example, if it is between the `min` attribute and the `low` attribute, then the lower range is considered preferred. The browser may color the meter's bar differently depending on whether the value is less than or equal to the optimum value.
+     */
+    optimum?: Numeric;
+}